mirror of
https://github.com/catchorg/Catch2.git
synced 2024-12-22 19:33:29 +01:00
Added ElementsAre and UnorderedElementsAre (#2377)
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
GitHub
parent
dd36f83b88
commit
efca9a0f18
@ -231,6 +231,10 @@ definitions to handle generic range-like types. These are:
|
||||
* `AllTrue()`
|
||||
* `NoneTrue()`
|
||||
* `AnyTrue()`
|
||||
* `RangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
|
||||
* `UnorderedRangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
|
||||
|
||||
> `RangeEquals` and `UnorderedRangeEquals` matchers were [introduced](https://github.com/catchorg/Catch2/pull/2377) in Catch2 X.Y.Z
|
||||
|
||||
`IsEmpty` should be self-explanatory. It successfully matches objects
|
||||
that are empty according to either `std::empty`, or ADL-found `empty`
|
||||
@ -257,6 +261,25 @@ all, none, or any of the contained elements are `true`, respectively.
|
||||
It works for ranges of `bool`s and ranges of elements (explicitly)
|
||||
convertible to `bool`.
|
||||
|
||||
`RangeEquals` compares the range that the matcher is constructed with
|
||||
(the "target range") against the range to be tested, element-wise. The
|
||||
match succeeds if all elements from the two ranges compare equal (using
|
||||
`operator==` by default). The ranges do not need to be the same type,
|
||||
and the element types do not need to be the same, as long as they are
|
||||
comparable. (e.g. you may compare `std::vector<int>` to `std::array<char>`).
|
||||
|
||||
`UnorderedRangeEquals` is similar to `RangeEquals`, but the order
|
||||
does not matter. For example "1, 2, 3" would match "3, 2, 1", but not
|
||||
"1, 1, 2, 3" As with `RangeEquals`, `UnorderedRangeEquals` compares
|
||||
the individual elements using using `operator==` by default.
|
||||
|
||||
Both `RangeEquals` and `UnorderedRangeEquals` optionally accept a
|
||||
predicate which can be used to compare the containers element-wise.
|
||||
|
||||
To check a container elementwise against a given matcher, use
|
||||
`AllMatch`.
|
||||
|
||||
|
||||
## Writing custom matchers (old style)
|
||||
|
||||
The old style of writing matchers has been introduced back in Catch
|
||||
|
||||
@ -252,6 +252,7 @@ set(MATCHER_HEADERS
|
||||
${SOURCES_DIR}/matchers/catch_matchers_all.hpp
|
||||
${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
|
||||
${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
|
||||
${SOURCES_DIR}/matchers/catch_matchers_range_equals.hpp
|
||||
${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
|
||||
${SOURCES_DIR}/matchers/catch_matchers_floating_point.hpp
|
||||
${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
|
||||
|
||||
@ -27,6 +27,7 @@
|
||||
#include <catch2/matchers/catch_matchers_floating_point.hpp>
|
||||
#include <catch2/matchers/catch_matchers_predicate.hpp>
|
||||
#include <catch2/matchers/catch_matchers_quantifiers.hpp>
|
||||
#include <catch2/matchers/catch_matchers_range_equals.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
#include <catch2/matchers/catch_matchers_templated.hpp>
|
||||
#include <catch2/matchers/catch_matchers_vector.hpp>
|
||||
|
||||
136
src/catch2/matchers/catch_matchers_range_equals.hpp
Normal file
136
src/catch2/matchers/catch_matchers_range_equals.hpp
Normal file
@ -0,0 +1,136 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
|
||||
#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
|
||||
|
||||
#include <algorithm>
|
||||
#include <catch2/matchers/catch_matchers_templated.hpp>
|
||||
#include <utility>
|
||||
|
||||
namespace Catch {
|
||||
namespace Matchers {
|
||||
|
||||
/**
|
||||
* Matcher for checking that an element contains the same
|
||||
* elements in the same order
|
||||
*/
|
||||
template <typename TargetRangeLike, typename Equality>
|
||||
class RangeEqualsMatcher final : public MatcherGenericBase {
|
||||
TargetRangeLike m_desired;
|
||||
Equality m_predicate;
|
||||
|
||||
public:
|
||||
template <typename TargetRangeLike2, typename Equality2>
|
||||
RangeEqualsMatcher( TargetRangeLike2&& range,
|
||||
Equality2&& predicate ):
|
||||
m_desired( CATCH_FORWARD( range ) ),
|
||||
m_predicate( CATCH_FORWARD( predicate ) ) {}
|
||||
|
||||
template <typename RangeLike>
|
||||
bool match( RangeLike&& rng ) const {
|
||||
using std::begin;
|
||||
using std::end;
|
||||
return std::equal( begin(m_desired),
|
||||
end(m_desired),
|
||||
begin(rng),
|
||||
end(rng),
|
||||
m_predicate );
|
||||
}
|
||||
|
||||
std::string describe() const override {
|
||||
return "elements are " + Catch::Detail::stringify( m_desired );
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Matcher for checking that an element contains the same
|
||||
* elements (but not necessarily in the same order)
|
||||
*/
|
||||
template <typename TargetRangeLike, typename Equality>
|
||||
class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
|
||||
TargetRangeLike m_desired;
|
||||
Equality m_predicate;
|
||||
|
||||
public:
|
||||
template <typename TargetRangeLike2, typename Equality2>
|
||||
UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
|
||||
Equality2&& predicate ):
|
||||
m_desired( CATCH_FORWARD( range ) ),
|
||||
m_predicate( CATCH_FORWARD( predicate ) ) {}
|
||||
|
||||
template <typename RangeLike>
|
||||
bool match( RangeLike&& rng ) const {
|
||||
using std::begin;
|
||||
using std::end;
|
||||
return std::is_permutation( begin( m_desired ),
|
||||
end( m_desired ),
|
||||
begin( rng ),
|
||||
end( rng ),
|
||||
m_predicate );
|
||||
}
|
||||
|
||||
std::string describe() const override {
|
||||
return "unordered elements are " +
|
||||
::Catch::Detail::stringify( m_desired );
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a matcher that checks if all elements in a range are equal
|
||||
* to all elements in another range.
|
||||
*
|
||||
* Uses `std::equal_to` to do the comparison
|
||||
*/
|
||||
template <typename RangeLike>
|
||||
std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
|
||||
RangeEqualsMatcher<RangeLike, std::equal_to<>>>
|
||||
RangeEquals( RangeLike&& range ) {
|
||||
return { CATCH_FORWARD( range ), std::equal_to<>{} };
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a matcher that checks if all elements in a range are equal
|
||||
* to all elements in another range.
|
||||
*
|
||||
* Uses to provided predicate `predicate` to do the comparisons
|
||||
*/
|
||||
template <typename RangeLike, typename Equality>
|
||||
RangeEqualsMatcher<RangeLike, Equality>
|
||||
RangeEquals( RangeLike&& range, Equality&& predicate ) {
|
||||
return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a matcher that checks if all elements in a range are equal
|
||||
* to all elements in another range, in some permutation
|
||||
*
|
||||
* Uses `std::equal_to` to do the comparison
|
||||
*/
|
||||
template <typename RangeLike>
|
||||
std::enable_if_t<
|
||||
!Detail::is_matcher<RangeLike>::value,
|
||||
UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
|
||||
UnorderedRangeEquals( RangeLike&& range ) {
|
||||
return { CATCH_FORWARD( range ), std::equal_to<>{} };
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a matcher that checks if all elements in a range are equal
|
||||
* to all elements in another range, in some permuation.
|
||||
*
|
||||
* Uses to provided predicate `predicate` to do the comparisons
|
||||
*/
|
||||
template <typename RangeLike, typename Equality>
|
||||
UnorderedRangeEqualsMatcher<RangeLike, Equality>
|
||||
UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
|
||||
return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
|
||||
}
|
||||
} // namespace Matchers
|
||||
} // namespace Catch
|
||||
|
||||
#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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=""*" ~[!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"/>
|
||||
|
||||
@ -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=""*" ~[!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"/>
|
||||
|
||||
@ -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}"/>
|
||||
|
||||
@ -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}"/>
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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']
|
||||
|
||||
@ -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']
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -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 ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user