3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2025-08-01 21:05:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

Added ElementsAre and UnorderedElementsAre (#2377)

Browse Source 
Co-authored-by: Garz4 <fancygarz4@gmail.com>
Co-authored-by: Martin Hořeňovský <martin.horenovsky@gmail.com>
This commit is contained in:
John Beard
2023-01-21 23:33:04 +00:00
committed by GitHub
parent dd36f83b88
commit efca9a0f18
22 changed files with 2334 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/SelfTest/Baselines/automake.sw.approved.txt
View File

@@ -269,6 +269,7 @@ Message from section two
: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
@@ -277,6 +278,8 @@ Message from section two
: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

3
tests/SelfTest/Baselines/automake.sw.multi.approved.txt
View File

@@ -262,6 +262,7 @@
: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
@@ -270,6 +271,8 @@
: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

40
tests/SelfTest/Baselines/compact.sw.approved.txt
View File

@@ -1859,6 +1859,23 @@ There is no extra whitespace here
StringManip.tests.cpp:<line number>: passed: trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here
==
There is no extra whitespace here
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: passed: a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
MatchersRanges.tests.cpp:<line number>: passed: a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
@@ -1964,6 +1981,25 @@ MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: { } has size == 0
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: { } not has size == 2
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: { } size matches is less than 2
@@ -2485,7 +2521,7 @@ InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
test cases: 404 | 305 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2173 | 1997 passed | 145 failed | 31 failed as expected
test cases: 407 | 308 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2209 | 2033 passed | 145 failed | 31 failed as expected

40
tests/SelfTest/Baselines/compact.sw.multi.approved.txt
View File

@@ -1852,6 +1852,23 @@ There is no extra whitespace here
StringManip.tests.cpp:<line number>: passed: trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here
==
There is no extra whitespace here
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: passed: a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
MatchersRanges.tests.cpp:<line number>: passed: a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
@@ -1957,6 +1974,25 @@ MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: { } has size == 0
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: { } not has size == 2
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: { } size matches is less than 2
@@ -2474,7 +2510,7 @@ InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
test cases: 404 | 305 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2173 | 1997 passed | 145 failed | 31 failed as expected
test cases: 407 | 308 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2209 | 2033 passed | 145 failed | 31 failed as expected

4
tests/SelfTest/Baselines/console.std.approved.txt
View File

@@ -1523,6 +1523,6 @@ due to unexpected exception with message:
Why would you throw a std::string?
===============================================================================
test cases: 404 | 319 passed | 69 failed | 6 skipped | 10 failed as expected
assertions: 2156 | 1997 passed | 128 failed | 31 failed as expected
test cases: 407 | 322 passed | 69 failed | 6 skipped | 10 failed as expected
assertions: 2192 | 2033 passed | 128 failed | 31 failed as expected

375
tests/SelfTest/Baselines/console.sw.approved.txt
View File

@@ -13098,6 +13098,154 @@ with expansion:
==
There is no extra whitespace here
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers of different container types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, RangeEquals( c_array ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, UnorderedRangeEquals( c_array ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers of different container types (differ in array N)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_3, !RangeEquals( array_int_4 ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_3, !UnorderedRangeEquals( array_int_4 ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers of different container types and value types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, RangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers, one random access, one not
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
with message:
ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess(
list_char_a )
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, RangeEquals( list_char_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, UnorderedRangeEquals( list_char_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Value type
Two equal containers of different value types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, RangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Value type
Two non-equal containers of different value types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, !RangeEquals( vector_char_b ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, !UnorderedRangeEquals( vector_char_b ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Ranges with begin that needs ADL
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_THAT( a, !RangeEquals( b ) )
with expansion:
{ 1, 2, 3 } not elements are { 3, 2, 1 }
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_THAT( a, UnorderedRangeEquals( b ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 3, 2, 1 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Custom predicate
Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, RangeEquals( array_a_plus_1, close_enough ) )
with expansion:
{ 1, 2, 3 } elements are { 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 2, 3, 4 }
-------------------------------------------------------------------------------
Unexpected exceptions can be translated
-------------------------------------------------------------------------------
@@ -13957,6 +14105,229 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
with expansion:
!false
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Empty container matches empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, RangeEquals( empty_vector ) )
with expansion:
{ } elements are { }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Empty container does not match non-empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, !RangeEquals( non_empty_vector ) )
with expansion:
{ } not elements are { 1 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_vector, !RangeEquals( empty_vector ) )
with expansion:
{ 1 } not elements are { }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two equal 1-length non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_array, RangeEquals( non_empty_array ) )
with expansion:
{ 1 } elements are { 1 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two equal-sized, equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, RangeEquals( array_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two equal-sized, non-equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, !RangeEquals( array_b ) )
with expansion:
{ 1, 2, 3 } not elements are { 2, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, !RangeEquals( array_c ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two non-equal-sized, non-empty containers (with same first elements)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !RangeEquals( vector_b ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Custom predicate
Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, RangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
{ 1, 2, 3 } elements are { 2, 3, 4 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Custom predicate
Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !RangeEquals( vector_b, close_enough ) )
with expansion:
{ 1, 2, 3 } not elements are { 3, 3, 4 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Empty container matches empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, UnorderedRangeEquals( empty_vector ) )
with expansion:
{ } unordered elements are { }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Empty container does not match non-empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, !UnorderedRangeEquals( non_empty_vector ) )
with expansion:
{ } not unordered elements are { 1 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_vector, !UnorderedRangeEquals( empty_vector ) )
with expansion:
{ 1 } not unordered elements are { }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two equal 1-length non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_array, UnorderedRangeEquals( non_empty_array ) )
with expansion:
{ 1 } unordered elements are { 1 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two equal-sized, equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, UnorderedRangeEquals( array_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two equal-sized, non-equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, !UnorderedRangeEquals( array_b ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 2, 2, 3 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two non-equal-sized, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Custom predicate
Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
{ 1, 10, 20 } unordered elements are { 11, 21, 2 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Custom predicate
Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b, close_enough ) )
with expansion:
{ 1, 10, 21 } not unordered elements are { 11, 21, 3 }
-------------------------------------------------------------------------------
Usage of the SizeIs range matcher
Some with stdlib containers
@@ -17722,6 +18093,6 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
===============================================================================
test cases: 404 | 305 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2173 | 1997 passed | 145 failed | 31 failed as expected
test cases: 407 | 308 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2209 | 2033 passed | 145 failed | 31 failed as expected

375
tests/SelfTest/Baselines/console.sw.multi.approved.txt
View File

@@ -13091,6 +13091,154 @@ with expansion:
==
There is no extra whitespace here
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers of different container types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, RangeEquals( c_array ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, UnorderedRangeEquals( c_array ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers of different container types (differ in array N)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_3, !RangeEquals( array_int_4 ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_3, !UnorderedRangeEquals( array_int_4 ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers of different container types and value types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, RangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Container conversions
Two equal containers, one random access, one not
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
with message:
ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess(
list_char_a )
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, RangeEquals( list_char_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_int_a, UnorderedRangeEquals( list_char_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Value type
Two equal containers of different value types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, RangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Value type
Two non-equal containers of different value types
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, !RangeEquals( vector_char_b ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 2 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_int_a, !UnorderedRangeEquals( vector_char_b ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Ranges with begin that needs ADL
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_THAT( a, !RangeEquals( b ) )
with expansion:
{ 1, 2, 3 } not elements are { 3, 2, 1 }
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_THAT( a, UnorderedRangeEquals( b ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 3, 2, 1 }
-------------------------------------------------------------------------------
Type conversions of RangeEquals and similar
Custom predicate
Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, RangeEquals( array_a_plus_1, close_enough ) )
with expansion:
{ 1, 2, 3 } elements are { 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 2, 3, 4 }
-------------------------------------------------------------------------------
Unexpected exceptions can be translated
-------------------------------------------------------------------------------
@@ -13950,6 +14098,229 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
with expansion:
!false
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Empty container matches empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, RangeEquals( empty_vector ) )
with expansion:
{ } elements are { }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Empty container does not match non-empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, !RangeEquals( non_empty_vector ) )
with expansion:
{ } not elements are { 1 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_vector, !RangeEquals( empty_vector ) )
with expansion:
{ 1 } not elements are { }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two equal 1-length non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_array, RangeEquals( non_empty_array ) )
with expansion:
{ 1 } elements are { 1 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two equal-sized, equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, RangeEquals( array_a ) )
with expansion:
{ 1, 2, 3 } elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two equal-sized, non-equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, !RangeEquals( array_b ) )
with expansion:
{ 1, 2, 3 } not elements are { 2, 2, 3 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, !RangeEquals( array_c ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Basic usage
Two non-equal-sized, non-empty containers (with same first elements)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !RangeEquals( vector_b ) )
with expansion:
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Custom predicate
Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, RangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
{ 1, 2, 3 } elements are { 2, 3, 4 }
-------------------------------------------------------------------------------
Usage of RangeEquals range matcher
Custom predicate
Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !RangeEquals( vector_b, close_enough ) )
with expansion:
{ 1, 2, 3 } not elements are { 3, 3, 4 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Empty container matches empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, UnorderedRangeEquals( empty_vector ) )
with expansion:
{ } unordered elements are { }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Empty container does not match non-empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( empty_vector, !UnorderedRangeEquals( non_empty_vector ) )
with expansion:
{ } not unordered elements are { 1 }
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_vector, !UnorderedRangeEquals( empty_vector ) )
with expansion:
{ 1 } not unordered elements are { }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two equal 1-length non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( non_empty_array, UnorderedRangeEquals( non_empty_array ) )
with expansion:
{ 1 } unordered elements are { 1 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two equal-sized, equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, UnorderedRangeEquals( array_a ) )
with expansion:
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two equal-sized, non-equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( array_a, !UnorderedRangeEquals( array_b ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 2, 2, 3 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Basic usage
Two non-equal-sized, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b ) )
with expansion:
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Custom predicate
Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
{ 1, 10, 20 } unordered elements are { 11, 21, 2 }
-------------------------------------------------------------------------------
Usage of UnorderedRangeEquals range matcher
Custom predicate
Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b, close_enough ) )
with expansion:
{ 1, 10, 21 } not unordered elements are { 11, 21, 3 }
-------------------------------------------------------------------------------
Usage of the SizeIs range matcher
Some with stdlib containers
@@ -17711,6 +18082,6 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
===============================================================================
test cases: 404 | 305 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2173 | 1997 passed | 145 failed | 31 failed as expected
test cases: 407 | 308 passed | 84 failed | 5 skipped | 10 failed as expected
assertions: 2209 | 2033 passed | 145 failed | 31 failed as expected

26
tests/SelfTest/Baselines/junit.sw.approved.txt
View File

@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<testsuitesloose text artifact
>
<testsuite name="<exe-name>" errors="17" failures="128" skipped="11" tests="2184" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
<testsuite name="<exe-name>" errors="17" failures="128" skipped="11" tests="2220" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
<properties>
<property name="random-seed" value="1"/>
<property name="filters" value="&quot;*&quot; ~[!nonportable] ~[!benchmark] ~[approvals]"/>
@@ -1367,6 +1367,14 @@ at Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Tracker/successfully close one section, then find another/Re-enter - skips S1 and enters S2/fail S2" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Tracker/open a nested section" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Trim strings" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Unexpected exceptions can be translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
@@ -1415,6 +1423,22 @@ at Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>

26
tests/SelfTest/Baselines/junit.sw.multi.approved.txt
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<testsuites>
<testsuite name="<exe-name>" errors="17" failures="128" skipped="11" tests="2184" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
<testsuite name="<exe-name>" errors="17" failures="128" skipped="11" tests="2220" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
<properties>
<property name="random-seed" value="1"/>
<property name="filters" value="&quot;*&quot; ~[!nonportable] ~[!benchmark] ~[approvals]"/>
@@ -1366,6 +1366,14 @@ at Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Tracker/successfully close one section, then find another/Re-enter - skips S1 and enters S2/fail S2" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Tracker/open a nested section" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Trim strings" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Unexpected exceptions can be translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
@@ -1414,6 +1422,22 @@ at Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>

24
tests/SelfTest/Baselines/sonarqube.sw.approved.txt
View File

@@ -1365,6 +1365,14 @@ at Matchers.tests.cpp:<line number>
<testCase name="Basic use of the Empty range matcher/Simple, std-provided containers" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type with empty" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type requires ADL found empty free function" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Basic usage" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
@@ -1404,6 +1412,22 @@ at Matchers.tests.cpp:<line number>
<testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>

24
tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
View File

@@ -1364,6 +1364,14 @@ at Matchers.tests.cpp:<line number>
<testCase name="Basic use of the Empty range matcher/Simple, std-provided containers" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type with empty" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type requires ADL found empty free function" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" duration="{duration}"/>
<testCase name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Basic usage" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
@@ -1403,6 +1411,22 @@ at Matchers.tests.cpp:<line number>
<testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>

74
tests/SelfTest/Baselines/tap.sw.approved.txt
View File

@@ -3223,6 +3223,40 @@ ok {test-number} - trim(StringRef(leading_whitespace)) == StringRef(no_whitespac
ok {test-number} - trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
# Trim strings
ok {test-number} - trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
# Type conversions of RangeEquals and similar
ok {test-number} - a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
# Type conversions of RangeEquals and similar
ok {test-number} - a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
# Unexpected exceptions can be translated
not ok {test-number} - unexpected exception with message: '3.14'
# Upcasting special member functions
@@ -3433,6 +3467,44 @@ ok {test-number} - mocked.m_derefed[2] for: true
ok {test-number} - !(mocked.m_derefed[3]) for: !false
# Usage of NoneTrue range matcher
ok {test-number} - !(mocked.m_derefed[4]) for: !false
# Usage of RangeEquals range matcher
ok {test-number} - empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
# Usage of RangeEquals range matcher
ok {test-number} - empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
# Usage of RangeEquals range matcher
ok {test-number} - non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
# Usage of RangeEquals range matcher
ok {test-number} - non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
# Usage of RangeEquals range matcher
ok {test-number} - array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Usage of RangeEquals range matcher
ok {test-number} - array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
# Usage of RangeEquals range matcher
ok {test-number} - array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
# Usage of RangeEquals range matcher
ok {test-number} - vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
# Usage of RangeEquals range matcher
ok {test-number} - vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
# Usage of RangeEquals range matcher
ok {test-number} - vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
# Usage of the SizeIs range matcher
ok {test-number} - empty_vec, SizeIs(0) for: { } has size == 0
# Usage of the SizeIs range matcher
@@ -4371,5 +4443,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
ok {test-number} -
# xmlentitycheck
ok {test-number} -
1..2184
1..2220

74
tests/SelfTest/Baselines/tap.sw.multi.approved.txt
View File

@@ -3216,6 +3216,40 @@ ok {test-number} - trim(StringRef(leading_whitespace)) == StringRef(no_whitespac
ok {test-number} - trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
# Trim strings
ok {test-number} - trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
# Type conversions of RangeEquals and similar
ok {test-number} - a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
# Type conversions of RangeEquals and similar
ok {test-number} - a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
# Type conversions of RangeEquals and similar
ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
# Unexpected exceptions can be translated
not ok {test-number} - unexpected exception with message: '3.14'
# Upcasting special member functions
@@ -3426,6 +3460,44 @@ ok {test-number} - mocked.m_derefed[2] for: true
ok {test-number} - !(mocked.m_derefed[3]) for: !false
# Usage of NoneTrue range matcher
ok {test-number} - !(mocked.m_derefed[4]) for: !false
# Usage of RangeEquals range matcher
ok {test-number} - empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
# Usage of RangeEquals range matcher
ok {test-number} - empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
# Usage of RangeEquals range matcher
ok {test-number} - non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
# Usage of RangeEquals range matcher
ok {test-number} - non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
# Usage of RangeEquals range matcher
ok {test-number} - array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
# Usage of RangeEquals range matcher
ok {test-number} - array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
# Usage of RangeEquals range matcher
ok {test-number} - array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
# Usage of RangeEquals range matcher
ok {test-number} - vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
# Usage of RangeEquals range matcher
ok {test-number} - vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
# Usage of RangeEquals range matcher
ok {test-number} - vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
# Usage of UnorderedRangeEquals range matcher
ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
# Usage of the SizeIs range matcher
ok {test-number} - empty_vec, SizeIs(0) for: { } has size == 0
# Usage of the SizeIs range matcher
@@ -4360,5 +4432,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
ok {test-number} -
# xmlentitycheck
ok {test-number} -
1..2184
1..2220

6
tests/SelfTest/Baselines/teamcity.sw.approved.txt
View File

@@ -646,6 +646,8 @@
##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}"]
@@ -663,6 +665,10 @@
##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']

6
tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
View File

@@ -646,6 +646,8 @@
##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}"]
@@ -663,6 +665,10 @@
##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']

434
tests/SelfTest/Baselines/xml.sw.approved.txt
View File

@@ -15253,6 +15253,182 @@ There is no extra whitespace here
</Expression>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Type conversions of RangeEquals and similar" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different container types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, RangeEquals( c_array )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, UnorderedRangeEquals( c_array )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different container types (differ in array N)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_3, !RangeEquals( array_int_4 )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_3, !UnorderedRangeEquals( array_int_4 )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different container types and value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, RangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, UnorderedRangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers, one random access, one not" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, RangeEquals( list_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, UnorderedRangeEquals( list_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, RangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, UnorderedRangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, !RangeEquals( vector_char_b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 2 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, !UnorderedRangeEquals( vector_char_b )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 1, 2, 2 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Ranges with begin that needs ADL" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
a, !RangeEquals( b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 3, 2, 1 }
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
a, UnorderedRangeEquals( b )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 3, 2, 1 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, RangeEquals( array_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 2, 3, 4 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Unexpected exceptions can be translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
3.14
@@ -16334,6 +16510,260 @@ There is no extra whitespace here
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of RangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, RangeEquals( empty_vector )
</Original>
<Expanded>
{ } elements are { }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, !RangeEquals( non_empty_vector )
</Original>
<Expanded>
{ } not elements are { 1 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_vector, !RangeEquals( empty_vector )
</Original>
<Expanded>
{ 1 } not elements are { }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_array, RangeEquals( non_empty_array )
</Original>
<Expanded>
{ 1 } elements are { 1 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, RangeEquals( array_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, !RangeEquals( array_b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 2, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, !RangeEquals( array_c )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 2 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal-sized, non-empty containers (with same first elements)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !RangeEquals( vector_b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, RangeEquals( vector_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !RangeEquals( vector_b, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 3, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of UnorderedRangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, UnorderedRangeEquals( empty_vector )
</Original>
<Expanded>
{ } unordered elements are { }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, !UnorderedRangeEquals( non_empty_vector )
</Original>
<Expanded>
{ } not unordered elements are { 1 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_vector, !UnorderedRangeEquals( empty_vector )
</Original>
<Expanded>
{ 1 } not unordered elements are { }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_array, UnorderedRangeEquals( non_empty_array )
</Original>
<Expanded>
{ 1 } unordered elements are { 1 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, UnorderedRangeEquals( array_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, !UnorderedRangeEquals( array_b )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 2, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal-sized, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !UnorderedRangeEquals( vector_b )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 10, 20 } unordered elements are { 11, 21, 2 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !UnorderedRangeEquals( vector_b, close_enough )
</Original>
<Expanded>
{ 1, 10, 21 } not unordered elements are { 11, 21, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Some with stdlib containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -20612,6 +21042,6 @@ b1!
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<OverallResults successes="1997" failures="145" expectedFailures="31" skips="11"/>
<OverallResultsCases successes="305" failures="84" expectedFailures="10" skips="5"/>
<OverallResults successes="2033" failures="145" expectedFailures="31" skips="11"/>
<OverallResultsCases successes="308" failures="84" expectedFailures="10" skips="5"/>
</Catch2TestRun>

434
tests/SelfTest/Baselines/xml.sw.multi.approved.txt
View File

@@ -15253,6 +15253,182 @@ There is no extra whitespace here
</Expression>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Type conversions of RangeEquals and similar" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different container types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, RangeEquals( c_array )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, UnorderedRangeEquals( c_array )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different container types (differ in array N)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_3, !RangeEquals( array_int_4 )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_3, !UnorderedRangeEquals( array_int_4 )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different container types and value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, RangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, UnorderedRangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers, one random access, one not" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, RangeEquals( list_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_int_a, UnorderedRangeEquals( list_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, RangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, UnorderedRangeEquals( vector_char_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, !RangeEquals( vector_char_b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 2 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_int_a, !UnorderedRangeEquals( vector_char_b )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 1, 2, 2 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Ranges with begin that needs ADL" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
a, !RangeEquals( b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 3, 2, 1 }
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
a, UnorderedRangeEquals( b )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 3, 2, 1 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, RangeEquals( array_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 2, 3, 4 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Unexpected exceptions can be translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
3.14
@@ -16334,6 +16510,260 @@ There is no extra whitespace here
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of RangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, RangeEquals( empty_vector )
</Original>
<Expanded>
{ } elements are { }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, !RangeEquals( non_empty_vector )
</Original>
<Expanded>
{ } not elements are { 1 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_vector, !RangeEquals( empty_vector )
</Original>
<Expanded>
{ 1 } not elements are { }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_array, RangeEquals( non_empty_array )
</Original>
<Expanded>
{ 1 } elements are { 1 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, RangeEquals( array_a )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, !RangeEquals( array_b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 2, 2, 3 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, !RangeEquals( array_c )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 2 }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal-sized, non-empty containers (with same first elements)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !RangeEquals( vector_b )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, RangeEquals( vector_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } elements are { 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !RangeEquals( vector_b, close_enough )
</Original>
<Expanded>
{ 1, 2, 3 } not elements are { 3, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of UnorderedRangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, UnorderedRangeEquals( empty_vector )
</Original>
<Expanded>
{ } unordered elements are { }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
empty_vector, !UnorderedRangeEquals( non_empty_vector )
</Original>
<Expanded>
{ } not unordered elements are { 1 }
</Expanded>
</Expression>
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_vector, !UnorderedRangeEquals( empty_vector )
</Original>
<Expanded>
{ 1 } not unordered elements are { }
</Expanded>
</Expression>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
non_empty_array, UnorderedRangeEquals( non_empty_array )
</Original>
<Expanded>
{ 1 } unordered elements are { 1 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, UnorderedRangeEquals( array_a )
</Original>
<Expanded>
{ 1, 2, 3 } unordered elements are { 1, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
array_a, !UnorderedRangeEquals( array_b )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 2, 2, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal-sized, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !UnorderedRangeEquals( vector_b )
</Original>
<Expanded>
{ 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough )
</Original>
<Expanded>
{ 1, 10, 20 } unordered elements are { 11, 21, 2 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
vector_a, !UnorderedRangeEquals( vector_b, close_enough )
</Original>
<Expanded>
{ 1, 10, 21 } not unordered elements are { 11, 21, 3 }
</Expanded>
</Expression>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Some with stdlib containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -20611,6 +21041,6 @@ b1!
</Section>
<OverallResult success="true" skips="0"/>
</TestCase>
<OverallResults successes="1997" failures="145" expectedFailures="31" skips="11"/>
<OverallResultsCases successes="305" failures="84" expectedFailures="10" skips="5"/>
<OverallResults successes="2033" failures="145" expectedFailures="31" skips="11"/>
<OverallResultsCases successes="308" failures="84" expectedFailures="10" skips="5"/>
</Catch2TestRun>

223
tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
View File

@@ -9,6 +9,7 @@
#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>
@@ -832,3 +833,225 @@ TEST_CASE( "The quantifier range matchers support types with different types ret
}
#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 ) );
}
}
// Cannot usefully test short-circuits, as the complexiy of std::equal is
// only guaranteed to be O(n) or better (even if many implementations
// short-circuit if the range lengths differ for
// LegacyRandomAccessIterators)
}
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 ) );
}
}
// As above with RangeEquals, short cicuiting and other optimisations
// are left to the STL implementation
}
/**
* 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 ) );
}
}
}