testing::internal::ElementsAreMatcherImpl< Container > Class Template Reference

#include <gmock-matchers.h>

Inheritance diagram for testing::internal::ElementsAreMatcherImpl< Container >:

Collaboration diagram for testing::internal::ElementsAreMatcherImpl< Container >:

Public Types
typedef internal::StlContainerView< RawContainer >	View
typedef View::type	StlContainer
typedef View::const_reference	StlContainerReference
typedef StlContainer::value_type	Element

Public Member Functions
typedef	GTEST_REMOVE_REFERENCE_AND_CONST_ (Container) RawContainer
template<typename InputIter>
	ElementsAreMatcherImpl (InputIter first, InputIter last)
virtual void	DescribeTo (::std::ostream *os) const
virtual void	DescribeNegationTo (::std::ostream *os) const
virtual bool	MatchAndExplain (Container container, MatchResultListener *listener) const
Public Member Functions inherited from testing::MatcherDescriberInterface
virtual	~MatcherDescriberInterface ()

Detailed Description

template<typename Container>
class testing::internal::ElementsAreMatcherImpl< Container >

Definition at line 3108 of file gmock-matchers.h.

Member Typedef Documentation

Element

template<typename Container>

typedef StlContainer::value_type testing::internal::ElementsAreMatcherImpl< Container >::Element

Definition at line 3114 of file gmock-matchers.h.

StlContainer

template<typename Container>

typedef View::type testing::internal::ElementsAreMatcherImpl< Container >::StlContainer

Definition at line 3112 of file gmock-matchers.h.

StlContainerReference

template<typename Container>

typedef View::const_reference testing::internal::ElementsAreMatcherImpl< Container >::StlContainerReference

Definition at line 3113 of file gmock-matchers.h.

View

template<typename Container>

typedef internal::StlContainerView<RawContainer> testing::internal::ElementsAreMatcherImpl< Container >::View

Definition at line 3111 of file gmock-matchers.h.

Constructor & Destructor Documentation

ElementsAreMatcherImpl()

template<typename Container>

template<typename InputIter>

testing::internal::ElementsAreMatcherImpl< Container >::ElementsAreMatcherImpl ( InputIter first, InputIter last )

inline

Definition at line 3119 of file gmock-matchers.h.

                                                          {
    while (first != last) {
      matchers_.push_back(MatcherCast<const Element&>(*first++));
    }
  }

Here is the call graph for this function:

Member Function Documentation

DescribeNegationTo()

template<typename Container>

virtual void testing::internal::ElementsAreMatcherImpl< Container >::DescribeNegationTo ( ::std::ostream * os ) const

inlinevirtual

Reimplemented from testing::MatcherDescriberInterface.

Definition at line 3145 of file gmock-matchers.h.

                                                        {
    if (count() == 0) {
      *os << "isn't empty";
      return;
    }
 
    *os << "doesn't have " << Elements(count()) << ", or\n";
    for (size_t i = 0; i != count(); ++i) {
      *os << "element #" << i << " ";
      matchers_[i].DescribeNegationTo(os);
      if (i + 1 < count()) {
        *os << ", or\n";
      }
    }
  }

DescribeTo()

template<typename Container>

virtual void testing::internal::ElementsAreMatcherImpl< Container >::DescribeTo ( ::std::ostream * os ) const

inlinevirtual

Implements testing::MatcherDescriberInterface.

Definition at line 3126 of file gmock-matchers.h.

                                                {
    if (count() == 0) {
      *os << "is empty";
    } else if (count() == 1) {
      *os << "has 1 element that ";
      matchers_[0].DescribeTo(os);
    } else {
      *os << "has " << Elements(count()) << " where\n";
      for (size_t i = 0; i != count(); ++i) {
        *os << "element #" << i << " ";
        matchers_[i].DescribeTo(os);
        if (i + 1 < count()) {
          *os << ",\n";
        }
      }
    }
  }

GTEST_REMOVE_REFERENCE_AND_CONST_()

template<typename Container>

typedef testing::internal::ElementsAreMatcherImpl< Container >::GTEST_REMOVE_REFERENCE_AND_CONST_

(

Container

)

MatchAndExplain()

template<typename Container>

virtual bool testing::internal::ElementsAreMatcherImpl< Container >::MatchAndExplain ( Container container, MatchResultListener * listener ) const

inlinevirtual

Implements testing::MatcherInterface< Container >.

Definition at line 3161 of file gmock-matchers.h.

                                                                    {
    // To work with stream-like "containers", we must only walk
    // through the elements in one pass.
 
    const bool listener_interested = listener->IsInterested();
 
    // explanations[i] is the explanation of the element at index i.
    ::std::vector<internal::string> explanations(count());
    StlContainerReference stl_container = View::ConstReference(container);
    typename StlContainer::const_iterator it = stl_container.begin();
    size_t exam_pos = 0;
    bool mismatch_found = false;  // Have we found a mismatched element yet?
 
    // Go through the elements and matchers in pairs, until we reach
    // the end of either the elements or the matchers, or until we find a
    // mismatch.
    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
      bool match;  // Does the current element match the current matcher?
      if (listener_interested) {
        StringMatchResultListener s;
        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
        explanations[exam_pos] = s.str();
      } else {
        match = matchers_[exam_pos].Matches(*it);
      }
 
      if (!match) {
        mismatch_found = true;
        break;
      }
    }
    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
 
    // Find how many elements the actual container has.  We avoid
    // calling size() s.t. this code works for stream-like "containers"
    // that don't define size().
    size_t actual_count = exam_pos;
    for (; it != stl_container.end(); ++it) {
      ++actual_count;
    }
 
    if (actual_count != count()) {
      // The element count doesn't match.  If the container is empty,
      // there's no need to explain anything as Google Mock already
      // prints the empty container.  Otherwise we just need to show
      // how many elements there actually are.
      if (listener_interested && (actual_count != 0)) {
        *listener << "which has " << Elements(actual_count);
      }
      return false;
    }
 
    if (mismatch_found) {
      // The element count matches, but the exam_pos-th element doesn't match.
      if (listener_interested) {
        *listener << "whose element #" << exam_pos << " doesn't match";
        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
      }
      return false;
    }
 
    // Every element matches its expectation.  We need to explain why
    // (the obvious ones can be skipped).
    if (listener_interested) {
      bool reason_printed = false;
      for (size_t i = 0; i != count(); ++i) {
        const internal::string& s = explanations[i];
        if (!s.empty()) {
          if (reason_printed) {
            *listener << ",\nand ";
          }
          *listener << "whose element #" << i << " matches, " << s;
          reason_printed = true;
        }
      }
    }
    return true;
  }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/external/rapidjson/thirdparty/gtest/googlemock/include/gmock/gmock-matchers.h