testing::internal::UnorderedElementsAreMatcherImplBase Class Reference

#include <gmock-matchers.h>

Inheritance diagram for testing::internal::UnorderedElementsAreMatcherImplBase:

Protected Types
typedef ::std::vector< const MatcherDescriberInterface * >	MatcherDescriberVec

Protected Member Functions
	UnorderedElementsAreMatcherImplBase (UnorderedMatcherRequire::Flags matcher_flags)
void	DescribeToImpl (::std::ostream *os) const
void	DescribeNegationToImpl (::std::ostream *os) const
bool	VerifyMatchMatrix (const ::std::vector< std::string > &element_printouts, const MatchMatrix &matrix, MatchResultListener *listener) const
bool	FindPairing (const MatchMatrix &matrix, MatchResultListener *listener) const
MatcherDescriberVec &	matcher_describers ()
UnorderedMatcherRequire::Flags	match_flags () const

Static Protected Member Functions
static Message	Elements (size_t n)

Detailed Description

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

Member Typedef Documentation

MatcherDescriberVec

::std::vector<const MatcherDescriberInterface*> testing::internal::UnorderedElementsAreMatcherImplBase::MatcherDescriberVec

protected

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

Constructor & Destructor Documentation

UnorderedElementsAreMatcherImplBase()

testing::internal::UnorderedElementsAreMatcherImplBase::UnorderedElementsAreMatcherImplBase ( UnorderedMatcherRequire::Flags matcher_flags )

inlineexplicitprotected

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

      : match_flags_(matcher_flags) {}

Member Function Documentation

DescribeNegationToImpl()

void testing::internal::UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl ( ::std::ostream * os ) const

protected

Definition at line 435 of file gmock-matchers.cc.

                          {
  switch (match_flags()) {
    case UnorderedMatcherRequire::ExactMatch:
      if (matcher_describers_.empty()) {
        *os << "isn't empty";
        return;
      }
      if (matcher_describers_.size() == 1) {
        *os << "doesn't have " << Elements(1) << ", or has " << Elements(1)
            << " that ";
        matcher_describers_[0]->DescribeNegationTo(os);
        return;
      }
      *os << "doesn't have " << Elements(matcher_describers_.size())
          << ", or there exists no permutation of elements such that:\n";
      break;
    case UnorderedMatcherRequire::Superset:
      *os << "no surjection from elements to requirements exists such that:\n";
      break;
    case UnorderedMatcherRequire::Subset:
      *os << "no injection from elements to requirements exists such that:\n";
      break;
  }
  const char* sep = "";
  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
    *os << sep;
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      *os << " - element #" << i << " ";
    } else {
      *os << " - an element ";
    }
    matcher_describers_[i]->DescribeTo(os);
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      sep = ", and\n";
    } else {
      sep = "\n";
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DescribeToImpl()

void testing::internal::UnorderedElementsAreMatcherImplBase::DescribeToImpl ( ::std::ostream * os ) const

protected

Definition at line 394 of file gmock-matchers.cc.

                          {
  switch (match_flags()) {
    case UnorderedMatcherRequire::ExactMatch:
      if (matcher_describers_.empty()) {
        *os << "is empty";
        return;
      }
      if (matcher_describers_.size() == 1) {
        *os << "has " << Elements(1) << " and that element ";
        matcher_describers_[0]->DescribeTo(os);
        return;
      }
      *os << "has " << Elements(matcher_describers_.size())
          << " and there exists some permutation of elements such that:\n";
      break;
    case UnorderedMatcherRequire::Superset:
      *os << "a surjection from elements to requirements exists such that:\n";
      break;
    case UnorderedMatcherRequire::Subset:
      *os << "an injection from elements to requirements exists such that:\n";
      break;
  }
 
  const char* sep = "";
  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
    *os << sep;
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      *os << " - element #" << i << " ";
    } else {
      *os << " - an element ";
    }
    matcher_describers_[i]->DescribeTo(os);
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      sep = ", and\n";
    } else {
      sep = "\n";
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Elements()

static Message testing::internal::UnorderedElementsAreMatcherImplBase::Elements ( size_t n )

inlinestaticprotected

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

                                    {
    return Message() << n << " element" << (n == 1 ? "" : "s");
  }

Here is the caller graph for this function:

FindPairing()

bool testing::internal::UnorderedElementsAreMatcherImplBase::FindPairing ( const MatchMatrix & matrix, MatchResultListener * listener ) const

protected

Definition at line 531 of file gmock-matchers.cc.

                                                                    {
  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
 
  size_t max_flow = matches.size();
  if ((match_flags() & UnorderedMatcherRequire::Superset) &&
      max_flow < matrix.RhsSize()) {
    if (listener->IsInterested()) {
      *listener << "where no permutation of the elements can satisfy all "
                   "matchers, and the closest match is "
                << max_flow << " of " << matrix.RhsSize()
                << " matchers with the pairings:\n";
      LogElementMatcherPairVec(matches, listener->stream());
    }
    return false;
  }
  if ((match_flags() & UnorderedMatcherRequire::Subset) &&
      max_flow < matrix.LhsSize()) {
    if (listener->IsInterested()) {
      *listener
          << "where not all elements can be matched, and the closest match is "
          << max_flow << " of " << matrix.RhsSize()
          << " matchers with the pairings:\n";
      LogElementMatcherPairVec(matches, listener->stream());
    }
    return false;
  }
 
  if (matches.size() > 1) {
    if (listener->IsInterested()) {
      const char* sep = "where:\n";
      for (size_t mi = 0; mi < matches.size(); ++mi) {
        *listener << sep << " - element #" << matches[mi].first
                  << " is matched by matcher #" << matches[mi].second;
        sep = ",\n";
      }
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

match_flags()

UnorderedMatcherRequire::Flags testing::internal::UnorderedElementsAreMatcherImplBase::match_flags ( ) const

inlineprotected

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

{ return match_flags_; }

Here is the caller graph for this function:

matcher_describers()

MatcherDescriberVec & testing::internal::UnorderedElementsAreMatcherImplBase::matcher_describers ( )

inlineprotected

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

                                            {
    return matcher_describers_;
  }

Here is the caller graph for this function:

VerifyMatchMatrix()

bool testing::internal::UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix ( const ::std::vector< std::string > & element_printouts, const MatchMatrix & matrix, MatchResultListener * listener ) const

protected

Definition at line 481 of file gmock-matchers.cc.

                                                                    {
  bool result = true;
  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
 
  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
      char matched = matrix.HasEdge(ilhs, irhs);
      element_matched[ilhs] |= matched;
      matcher_matched[irhs] |= matched;
    }
  }
 
  if (match_flags() & UnorderedMatcherRequire::Superset) {
    const char* sep =
        "where the following matchers don't match any elements:\n";
    for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
      if (matcher_matched[mi]) continue;
      result = false;
      if (listener->IsInterested()) {
        *listener << sep << "matcher #" << mi << ": ";
        matcher_describers_[mi]->DescribeTo(listener->stream());
        sep = ",\n";
      }
    }
  }
 
  if (match_flags() & UnorderedMatcherRequire::Subset) {
    const char* sep =
        "where the following elements don't match any matchers:\n";
    const char* outer_sep = "";
    if (!result) {
      outer_sep = "\nand ";
    }
    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
      if (element_matched[ei]) continue;
      result = false;
      if (listener->IsInterested()) {
        *listener << outer_sep << sep << "element #" << ei << ": "
                  << element_printouts[ei];
        sep = ",\n";
        outer_sep = "";
      }
    }
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• libraries/fc/include/fc/crypto/webauthn_json/thirdparty/gtest/googlemock/include/gmock/gmock-matchers.h
• libraries/fc/include/fc/crypto/webauthn_json/thirdparty/gtest/googlemock/src/gmock-matchers.cc