Lines Matching refs:container
2293 // Implements a matcher that checks the size of an STL-style container.
2321 bool MatchAndExplain(Container container,
2323 SizeType size = container.size();
2341 // container.
2374 bool MatchAndExplain(Container container,
2378 DistanceType distance = std::distance(begin(container), end(container));
2396 // Implements an equality matcher for any STL-style container whose elements
2398 // more detailed information that is useful when the container is used as a set.
2404 // Uses the container's const_iterator, value_type, operator ==,
2573 // container and the RHS container respectively.
2707 // * All elements in the container match, if all_elements_should_match.
2708 // * Any element in the container matches, if !all_elements_should_match.
2709 bool MatchAndExplainImpl(bool all_elements_should_match, Container container,
2711 StlContainerReference stl_container = View::ConstReference(container);
2729 Container container,
2731 StlContainerReference stl_container = View::ConstReference(container);
2800 bool MatchAndExplain(Container container,
2802 return this->MatchAndExplainImpl(false, container, listener);
2826 bool MatchAndExplain(Container container,
2828 return this->MatchAndExplainImpl(true, container, listener);
2857 bool MatchAndExplain(Container container,
2859 return this->MatchAndExplainImpl(count_matcher_, container, listener);
3417 bool MatchAndExplain(Container container,
3426 StlContainerReference stl_container = View::ConstReference(container);
3451 // Find how many elements the actual container has. We avoid
3460 // The element count doesn't match. If the container is empty,
3462 // prints the empty container. Otherwise we just need to show
3640 bool MatchAndExplain(Container container,
3642 StlContainerReference stl_container = View::ConstReference(container);
4135 // ElementsAreArray(container)
4168 inline auto ElementsAreArray(const Container& container)
4169 -> decltype(ElementsAreArray(container.begin(), container.end())) {
4170 return ElementsAreArray(container.begin(), container.end());
4182 // UnorderedElementsAreArray(container)
4188 // The matchers can be specified as an array, a pointer and count, a container,
4216 UnorderedElementsAreArray(const Container& container) {
4217 return UnorderedElementsAreArray(container.begin(), container.end());
4672 // Returns a matcher that matches the container size. The container must
4676 // EXPECT_THAT(container, SizeIs(2)); // Checks container has 2 elements.
4677 // EXPECT_THAT(container, SizeIs(Le(2)); // Checks container has at most 2.
4684 // Returns a matcher that matches the distance between the container's begin()
4685 // iterator and its end() iterator, i.e. the size of the container. This matcher
4687 // do not implement size(). The container must provide const_iterator (with
4695 // Returns a matcher that matches an equal container.
4697 // values that are included in one container but not the other. (Duplicate
4706 // Returns a matcher that matches a container that, when sorted using
4715 // Returns a matcher that matches a container that, when sorted using
4725 // Matches an STL-style container or a native array that contains the
4730 // LHS container and the RHS container respectively.
4747 // container or a native array that contains the same number of
4748 // elements as in rhs, where in some permutation of the container, its
4752 // the types of elements in the LHS container and the RHS container
4766 // STL-style container and it being a native C-style array.
4793 // Matches an STL-style container or a native array that contains at
4832 // IsSupersetOf(container)
4836 // of matchers exists. In other words, a container matches
4838 // {y1, ..., yn} of some of the container's elements where y1 matches e1,
4839 // ..., and yn matches en. Obviously, the size of the container must be >= n
4846 // for elements in different slots of the container.
4852 // The matchers can be specified as an array, a pointer and count, a container,
4880 IsSupersetOf(const Container& container) {
4881 return IsSupersetOf(container.begin(), container.end());
4893 // IsSubsetOf(container)
4897 // exists. In other words, a container matches IsSubsetOf({e1, ..., en}) if and
4899 // container using UnorderedElementsAre. Obviously, the size of the container
4907 // elements in different slots of the container.
4909 // The matchers can be specified as an array, a pointer and count, a container,
4937 IsSubsetOf(const Container& container) {
4938 return IsSubsetOf(container.begin(), container.end());
4947 // Matches an STL-style container or a native array that contains only
4955 // // Each(m) matches an empty container, regardless of what m is.
5127 // AnyOfArray(container)
5136 // AllOfArray(container)
5143 // The matchers can be specified as an array, a pointer and count, a container,
5185 const Container& container) {
5186 return AnyOfArray(container.begin(), container.end());
5191 const Container& container) {
5192 return AllOfArray(container.begin(), container.end());