1f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Copyright 2007, Google Inc. 2f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// All rights reserved. 3f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Redistribution and use in source and binary forms, with or without 5f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// modification, are permitted provided that the following conditions are 6f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// met: 7f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 8f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Redistributions of source code must retain the above copyright 9f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// notice, this list of conditions and the following disclaimer. 10f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Redistributions in binary form must reproduce the above 11f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// copyright notice, this list of conditions and the following disclaimer 12f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// in the documentation and/or other materials provided with the 13f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// distribution. 14f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Neither the name of Google Inc. nor the names of its 15f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// contributors may be used to endorse or promote products derived from 16f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// this software without specific prior written permission. 17f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 18f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 30f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Author: wan@google.com (Zhanyong Wan) 31f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 32f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Google Mock - a framework for writing C++ mock classes. 33f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 34f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This file implements some commonly used argument matchers. More 35f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matchers can be defined by the user implementing the 36f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherInterface<T> interface if necessary. 37f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 38f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 39f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 40f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 41f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <math.h> 42f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <algorithm> 43f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <iterator> 44f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <limits> 45f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <ostream> // NOLINT 46f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <sstream> 47f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <string> 48f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <utility> 49f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <vector> 50f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 51f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gmock/internal/gmock-internal-utils.h" 52f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gmock/internal/gmock-port.h" 53f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/gtest.h" 54f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 55f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 56f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <initializer_list> // NOLINT -- must be after gtest.h 57f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 58f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 59f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace testing { 60f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 61f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// To implement a matcher Foo for type T, define: 62f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 1. a class FooMatcherImpl that implements the 63f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherInterface<T> interface, and 64f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 2. a factory function that creates a Matcher<T> object from a 65f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// FooMatcherImpl*. 66f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 67f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The two-level delegation design makes it possible to allow a user 68f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// to write "v" instead of "Eq(v)" where a Matcher is expected, which 69f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is impossible if we pass matchers by pointers. It also eases 70f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ownership management as Matcher objects can now be copied like 71f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// plain values. 72f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 73f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatchResultListener is an abstract class. Its << operator can be 74f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// used by a matcher to explain why a value matches or doesn't match. 75f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 76f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TODO(wan@google.com): add method 77f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// bool InterestedInWhy(bool result) const; 78f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// to indicate whether the listener is interested in why the match 79f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// result is 'result'. 80f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatchResultListener { 81f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 82f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Creates a listener object with the given underlying ostream. The 83f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // listener does not own the ostream, and does not dereference it 84f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // in the constructor or destructor. 85f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit MatchResultListener(::std::ostream* os) : stream_(os) {} 86f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual ~MatchResultListener() = 0; // Makes this class abstract. 87f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 88f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Streams x to the underlying ostream; does nothing if the ostream 89f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // is NULL. 90f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 91f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener& operator<<(const T& x) { 92f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (stream_ != NULL) 93f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *stream_ << x; 94f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return *this; 95f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 96f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 97f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the underlying ostream. 98f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* stream() { return stream_; } 99f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff the listener is interested in an explanation of 101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the match result. A matcher's MatchAndExplain() method can use 102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // this information to avoid generating the explanation when no one 103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // intends to hear it. 104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool IsInterested() const { return stream_ != NULL; } 105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* const stream_; 108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener); 110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline MatchResultListener::~MatchResultListener() { 113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// An instance of a subclass of this knows how to describe itself as a 116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher. 117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherDescriberInterface { 118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual ~MatcherDescriberInterface() {} 120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes this matcher to an ostream. The function should print 122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a verb phrase that describes the property a value matching this 123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher should have. The subject of the verb phrase is the value 124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // being matched. For example, the DescribeTo() method of the Gt(7) 125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher prints "is greater than 7". 126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const = 0; 127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes the negation of this matcher to an ostream. For 129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // example, if the description of this matcher is "is greater than 130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 7", the negated description could be "is not greater than 7". 131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // You are not required to override this when implementing 132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatcherInterface, but it is highly advised so that your matcher 133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // can produce good error messages. 134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "not ("; 136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeTo(os); 137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ")"; 138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The implementation of a matcher. 142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherInterface : public MatcherDescriberInterface { 144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff the matcher matches x; also explains the match 146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // result to 'listener' if necessary (see the next paragraph), in 147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the form of a non-restrictive relative clause ("which ...", 148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // "whose ...", etc) that describes x. For example, the 149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatchAndExplain() method of the Pointee(...) matcher should 150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // generate an explanation like "which points to ...". 151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Implementations of MatchAndExplain() should add an explanation of 153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the match result *if and only if* they can provide additional 154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // information that's not already present (or not obvious) in the 155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // print-out of x and the matcher's description. Whether the match 156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // succeeds is not a factor in deciding whether an explanation is 157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // needed, as sometimes the caller needs to print a failure message 158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // when the match succeeds (e.g. when the matcher is used inside 159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Not()). 160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // For example, a "has at least 10 elements" matcher should explain 162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // what the actual element count is, regardless of the match result, 163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // as it is useful information to the reader; on the other hand, an 164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // "is empty" matcher probably only needs to explain what the actual 165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // size is when the match fails, as it's redundant to say that the 166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // size is 0 when the value is already known to be empty. 167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // You should override this method when defining a new matcher. 169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // It's the responsibility of the caller (Google Mock) to guarantee 171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // that 'listener' is not NULL. This helps to simplify a matcher's 172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implementation when it doesn't care about the performance, as it 173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // can talk to 'listener' without checking its validity first. 174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // However, in order to implement dummy listeners efficiently, 175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // listener->stream() may be NULL. 176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; 177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Inherits these methods from MatcherDescriberInterface: 179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // virtual void DescribeTo(::std::ostream* os) const = 0; 180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // virtual void DescribeNegationTo(::std::ostream* os) const; 181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A match result listener that stores the explanation in a string. 184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass StringMatchResultListener : public MatchResultListener { 185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener() : MatchResultListener(&ss_) {} 187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the explanation accumulated so far. 189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::string str() const { return ss_.str(); } 190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Clears the explanation accumulated so far. 192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void Clear() { ss_.str(""); } 193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::stringstream ss_; 196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener); 198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AnyEq { 203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename A, typename B> 204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const A& a, const B& b) const { return a == b; } 205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AnyNe { 207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename A, typename B> 208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const A& a, const B& b) const { return a != b; } 209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AnyLt { 211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename A, typename B> 212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const A& a, const B& b) const { return a < b; } 213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AnyGt { 215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename A, typename B> 216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const A& a, const B& b) const { return a > b; } 217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AnyLe { 219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename A, typename B> 220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const A& a, const B& b) const { return a <= b; } 221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AnyGe { 223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename A, typename B> 224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const A& a, const B& b) const { return a >= b; } 225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A match result listener that ignores the explanation. 228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass DummyMatchResultListener : public MatchResultListener { 229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DummyMatchResultListener() : MatchResultListener(NULL) {} 231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener); 234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A match result listener that forwards the explanation to a given 237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ostream. The difference between this and MatchResultListener is 238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that the former is concrete. 239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass StreamMatchResultListener : public MatchResultListener { 240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit StreamMatchResultListener(::std::ostream* os) 242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : MatchResultListener(os) {} 243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener); 246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// An internal class for implementing Matcher<T>, which will derive 249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// from it. We put functionalities common to all Matcher<T> 250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// specializations here to avoid code duplication. 251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherBase { 253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff the matcher matches x; also explains the match 255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // result to 'listener'. 256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(T x, MatchResultListener* listener) const { 257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return impl_->MatchAndExplain(x, listener); 258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff this matcher matches x. 261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool Matches(T x) const { 262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DummyMatchResultListener dummy; 263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchAndExplain(x, &dummy); 264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes this matcher to an ostream. 267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); } 268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes the negation of this matcher to an ostream. 270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch impl_->DescribeNegationTo(os); 272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Explains why x matches, or doesn't match, the matcher. 275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void ExplainMatchResultTo(T x, ::std::ostream* os) const { 276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StreamMatchResultListener listener(os); 277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchAndExplain(x, &listener); 278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the describer for this matcher object; retains ownership 281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // of the describer, which is only guaranteed to be alive when 282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // this matcher object is alive. 283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const MatcherDescriberInterface* GetDescriber() const { 284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return impl_.get(); 285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherBase() {} 289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs a matcher from its implementation. 291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit MatcherBase(const MatcherInterface<T>* impl) 292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : impl_(impl) {} 293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual ~MatcherBase() {} 295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar 298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // interfaces. The former dynamically allocates a chunk of memory 299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to hold the reference count, while the latter tracks all 300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // references using a circular linked list without allocating 301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // memory. It has been observed that linked_ptr performs better in 302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // typical scenarios. However, shared_ptr can out-perform 303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // linked_ptr when there are many more uses of the copy constructor 304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // than the default constructor. 305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If performance becomes a problem, we should see if using 307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // shared_ptr helps. 308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_; 309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A Matcher<T> is a copyable and IMMUTABLE (except by assignment) 314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// object that can check whether a value of type T matches. The 315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// implementation of Matcher<T> is just a linked_ptr to const 316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherInterface<T>, so copying is fairly cheap. Don't inherit 317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// from Matcher! 318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Matcher : public internal::MatcherBase<T> { 320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs a null matcher. Needed for storing Matcher objects in STL 322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // containers. A default-constructed matcher is not yet initialized. You 323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // cannot use it until a valid value has been assigned to it. 324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Matcher() {} // NOLINT 325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs a matcher from its implementation. 327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Matcher(const MatcherInterface<T>* impl) 328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : internal::MatcherBase<T>(impl) {} 329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Implicit constructor here allows people to write 331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes 332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(T value); // NOLINT 333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The following two specializations allow the user to write str 336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// instead of Eq(str) and "foo" instead of Eq("foo") when a string 337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher is expected. 338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ Matcher<const internal::string&> 340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public internal::MatcherBase<const internal::string&> { 341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher() {} 343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Matcher(const MatcherInterface<const internal::string&>* impl) 345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : internal::MatcherBase<const internal::string&>(impl) {} 346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write str instead of Eq(str) sometimes, where 348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // str is a string object. 349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const internal::string& s); // NOLINT 350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write "foo" instead of Eq("foo") sometimes. 352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const char* s); // NOLINT 353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ Matcher<internal::string> 357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public internal::MatcherBase<internal::string> { 358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher() {} 360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Matcher(const MatcherInterface<internal::string>* impl) 362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : internal::MatcherBase<internal::string>(impl) {} 363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write str instead of Eq(str) sometimes, where 365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // str is a string object. 366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const internal::string& s); // NOLINT 367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write "foo" instead of Eq("foo") sometimes. 369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const char* s); // NOLINT 370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STRING_PIECE_ 373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The following two specializations allow the user to write str 374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece 375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher is expected. 376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ Matcher<const StringPiece&> 378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public internal::MatcherBase<const StringPiece&> { 379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher() {} 381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Matcher(const MatcherInterface<const StringPiece&>* impl) 383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : internal::MatcherBase<const StringPiece&>(impl) {} 384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write str instead of Eq(str) sometimes, where 386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // str is a string object. 387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const internal::string& s); // NOLINT 388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write "foo" instead of Eq("foo") sometimes. 390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const char* s); // NOLINT 391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to pass StringPieces directly. 393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(StringPiece s); // NOLINT 394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ Matcher<StringPiece> 398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public internal::MatcherBase<StringPiece> { 399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher() {} 401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Matcher(const MatcherInterface<StringPiece>* impl) 403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : internal::MatcherBase<StringPiece>(impl) {} 404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write str instead of Eq(str) sometimes, where 406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // str is a string object. 407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const internal::string& s); // NOLINT 408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to write "foo" instead of Eq("foo") sometimes. 410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(const char* s); // NOLINT 411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Allows the user to pass StringPieces directly. 413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher(StringPiece s); // NOLINT 414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STRING_PIECE_ 416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The PolymorphicMatcher class template makes it easy to implement a 418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// polymorphic matcher (i.e. a matcher that can match values of more 419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// than one type, e.g. Eq(n) and NotNull()). 420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// To define a polymorphic matcher, a user should provide an Impl 422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// class that has a DescribeTo() method and a DescribeNegationTo() 423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// method, and define a member function (or member function template) 424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// bool MatchAndExplain(const Value& value, 426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatchResultListener* listener) const; 427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// See the definition of NotNull() for a complete example. 429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <class Impl> 430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PolymorphicMatcher { 431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {} 433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns a mutable reference to the underlying matcher 435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implementation object. 436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl& mutable_impl() { return impl_; } 437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns an immutable reference to the underlying matcher 439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implementation object. 440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Impl& impl() const { return impl_; } 441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new MonomorphicImpl<T>(impl_)); 445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class MonomorphicImpl : public MatcherInterface<T> { 450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} 452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch impl_.DescribeTo(os); 455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch impl_.DescribeNegationTo(os); 459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { 462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return impl_.MatchAndExplain(x, listener); 463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Impl impl_; 467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(MonomorphicImpl); 469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl impl_; 472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher); 474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher from its implementation. This is easier to use 477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// than the Matcher<T> constructor as it doesn't require you to 478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// explicitly write the template argument, e.g. 479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MakeMatcher(foo); 481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// vs 482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<const string&>(foo); 483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) { 485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(impl); 486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher from its implementation. This is 489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// easier to use than the PolymorphicMatcher<Impl> constructor as it 490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// doesn't require you to explicitly write the template argument, e.g. 491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MakePolymorphicMatcher(foo); 493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// vs 494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// PolymorphicMatcher<TypeOfFoo>(foo); 495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <class Impl> 496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) { 497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return PolymorphicMatcher<Impl>(impl); 498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION 501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and MUST NOT BE USED IN USER CODE!!! 502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The MatcherCastImpl class template is a helper for implementing 505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherCast(). We need this helper in order to partially 506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// specialize the implementation of MatcherCast() (C++ allows 507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// class/struct templates to be partially specialized, but not 508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// function templates.). 509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This general version is used when MatcherCast()'s argument is a 511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// polymorphic matcher (i.e. something that can be converted to a 512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher but is not one yet; for example, Eq(value)) or a value (for 513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// example, "hello"). 514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename M> 515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherCastImpl { 516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> Cast(const M& polymorphic_matcher_or_value) { 518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // M can be a polymorhic matcher, in which case we want to use 519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // its conversion operator to create Matcher<T>. Or it can be a value 520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // that should be passed to the Matcher<T>'s constructor. 521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a 523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // polymorphic matcher because it'll be ambiguous if T has an implicit 524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // constructor from M (this usually happens when T has an implicit 525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // constructor from any type). 526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // It won't work to unconditionally implict_cast 528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // polymorphic_matcher_or_value to Matcher<T> because it won't trigger 529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a user-defined conversion from M to T if one exists (assuming M is 530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a value). 531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return CastImpl( 532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch polymorphic_matcher_or_value, 533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch BooleanConstant< 534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::ImplicitlyConvertible<M, Matcher<T> >::value>()); 535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) { 539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic 540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher. It must be a value then. Use direct initialization to create 541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a matcher. 542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(ImplicitCast_<T>(value)); 543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value, 546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch BooleanConstant<true>) { 547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // M is implicitly convertible to Matcher<T>, which means that either 548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // M is a polymorhpic matcher or Matcher<T> has an implicit constructor 549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // from M. In both cases using the implicit conversion will produce a 550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher. 551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Even if T has an implicit constructor from M, it won't be called because 553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // creating Matcher<T> would require a chain of two user-defined conversions 554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // (first to create T from M and then to create Matcher<T> from T). 555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return polymorphic_matcher_or_value; 556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This more specialized version is used when MatcherCast()'s argument 560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is already a Matcher. This only compiles when type T can be 561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// statically converted to type U. 562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename U> 563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherCastImpl<T, Matcher<U> > { 564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> Cast(const Matcher<U>& source_matcher) { 566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new Impl(source_matcher)); 567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<T> { 571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Impl(const Matcher<U>& source_matcher) 573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : source_matcher_(source_matcher) {} 574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We delegate the matching logic to the source matcher. 576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { 577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return source_matcher_.MatchAndExplain(static_cast<U>(x), listener); 578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch source_matcher_.DescribeTo(os); 582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch source_matcher_.DescribeNegationTo(os); 586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<U> source_matcher_; 590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This even more specialized version is used for efficiently casting 596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a matcher to its own type. 597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherCastImpl<T, Matcher<T> > { 599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; } 601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// In order to be safe and clear, casting between different matcher 606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// types is done explicitly via MatcherCast<T>(m), which takes a 607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher m and returns a Matcher<T>. It compiles only when T can be 608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// statically converted to the argument type of m. 609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename M> 610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline Matcher<T> MatcherCast(const M& matcher) { 611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::MatcherCastImpl<T, M>::Cast(matcher); 612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements SafeMatcherCast(). 615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We use an intermediate class to do the actual safe casting as Nokia's 617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Symbian compiler cannot decide between 618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// template <T, M> ... (M) and 619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// template <T, U> ... (const Matcher<U>&) 620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// for function templates but can for member function templates. 621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass SafeMatcherCastImpl { 623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This overload handles polymorphic matchers and values only since 625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // monomorphic matchers are handled by the next one. 626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename M> 627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) { 628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::MatcherCastImpl<T, M>::Cast(polymorphic_matcher_or_value); 629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This overload handles monomorphic matchers. 632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // In general, if type T can be implicitly converted to type U, we can 634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is 635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // contravariant): just keep a copy of the original Matcher<U>, convert the 636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // argument from type T to U, and then pass it to the underlying Matcher<U>. 637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The only exception is when U is a reference and T is not, as the 638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // underlying Matcher<U> may be interested in the argument's address, which 639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // is not preserved in the conversion from T to U. 640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename U> 641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static inline Matcher<T> Cast(const Matcher<U>& matcher) { 642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Enforce that T can be implicitly converted to U. 643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value), 644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch T_must_be_implicitly_convertible_to_U); 645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Enforce that we are not converting a non-reference type T to a reference 646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // type U. 647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_COMPILE_ASSERT_( 648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::is_reference<T>::value || !internal::is_reference<U>::value, 649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch cannot_convert_non_referentce_arg_to_reference); 650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // In case both T and U are arithmetic types, enforce that the 651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // conversion is not lossy. 652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT; 653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU; 654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther; 655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther; 656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_COMPILE_ASSERT_( 657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch kTIsOther || kUIsOther || 658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (internal::LosslessArithmeticConvertible<RawT, RawU>::value), 659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch conversion_of_arithmetic_types_must_be_lossless); 660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatcherCast<T>(matcher); 661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename M> 665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) { 666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher); 667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A<T>() returns a matcher that matches any value of type T. 670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMatcher<T> A(); 672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION 674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and MUST NOT BE USED IN USER CODE!!! 675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If the explanation is not empty, prints it to the ostream. 678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline void PrintIfNotEmpty(const internal::string& explanation, 679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* os) { 680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (explanation != "" && os != NULL) { 681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ", " << explanation; 682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns true if the given type name is easy to read by a human. 686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This is used to decide whether printing the type of a value might 687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// be helpful. 688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool IsReadableTypeName(const string& type_name) { 689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We consider a type name readable if it's short or doesn't contain 690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a template or function type. 691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (type_name.length() <= 20 || 692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch type_name.find_first_of("<(") == string::npos); 693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches the value against the given matcher, prints the value and explains 696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the match result to the listener. Returns the match result. 697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'listener' must not be NULL. 698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Value cannot be passed by const reference, because some matchers take a 699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// non-const argument. 700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Value, typename T> 701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher, 702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) { 703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!listener->IsInterested()) { 704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If the listener is not interested, we do not need to construct the 705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // inner explanation. 706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return matcher.Matches(value); 707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener inner_listener; 710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool match = matcher.MatchAndExplain(value, &inner_listener); 711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(value, listener->stream()); 713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_RTTI 714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string& type_name = GetTypeName<Value>(); 715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (IsReadableTypeName(type_name)) 716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener->stream() << " (of type " << type_name << ")"; 717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(inner_listener.str(), listener->stream()); 719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return match; 721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// An internal helper class for doing compile-time loop on a tuple's 724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// fields. 725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <size_t N> 726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TuplePrefix { 727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true 729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // iff the first N fields of matcher_tuple matches the first N 730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // fields of value_tuple, respectively. 731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcherTuple, typename ValueTuple> 732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool Matches(const MatcherTuple& matcher_tuple, 733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ValueTuple& value_tuple) { 734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) 735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple)); 736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os) 739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // describes failures in matching the first N fields of matchers 740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // against the first N fields of values. If there is no failure, 741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // nothing will be streamed to os. 742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcherTuple, typename ValueTuple> 743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void ExplainMatchFailuresTo(const MatcherTuple& matchers, 744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ValueTuple& values, 745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* os) { 746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // First, describes failures in the first N - 1 fields. 747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os); 748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Then describes the failure (if any) in the (N - 1)-th (0-based) 750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // field. 751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename tuple_element<N - 1, MatcherTuple>::type matcher = 752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch get<N - 1>(matchers); 753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename tuple_element<N - 1, ValueTuple>::type Value; 754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Value value = get<N - 1>(values); 755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!matcher.MatchAndExplain(value, &listener)) { 757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // TODO(wan): include in the message the name of the parameter 758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // as used in MOCK_METHOD*() when possible. 759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << " Expected arg #" << N - 1 << ": "; 760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch get<N - 1>(matchers).DescribeTo(os); 761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "\n Actual: "; 762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We remove the reference in type Value to prevent the 763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // universal printer from printing the address of value, which 764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // isn't interesting to the user most of the time. The 765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher's MatchAndExplain() method handles the case when 766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the address is interesting. 767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::UniversalPrint(value, os); 768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(listener.str(), os); 769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "\n"; 770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The base case. 775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <> 776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TuplePrefix<0> { 777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcherTuple, typename ValueTuple> 779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool Matches(const MatcherTuple& /* matcher_tuple */, 780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ValueTuple& /* value_tuple */) { 781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcherTuple, typename ValueTuple> 785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */, 786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ValueTuple& /* values */, 787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* /* os */) {} 788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TupleMatches(matcher_tuple, value_tuple) returns true iff all 791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matchers in matcher_tuple match the corresponding fields in 792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// value_tuple. It is a compiler error if matcher_tuple and 793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// value_tuple have different number of fields or incompatible field 794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// types. 795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename MatcherTuple, typename ValueTuple> 796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool TupleMatches(const MatcherTuple& matcher_tuple, 797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ValueTuple& value_tuple) { 798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Makes sure that matcher_tuple and value_tuple have the same 799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // number of fields. 800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value == 801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch tuple_size<ValueTuple>::value, 802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_and_value_have_different_numbers_of_fields); 803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return TuplePrefix<tuple_size<ValueTuple>::value>:: 804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matches(matcher_tuple, value_tuple); 805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Describes failures in matching matchers against values. If there 808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is no failure, nothing will be streamed to os. 809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename MatcherTuple, typename ValueTuple> 810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid ExplainMatchFailureTupleTo(const MatcherTuple& matchers, 811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ValueTuple& values, 812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* os) { 813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo( 814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers, values, os); 815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TransformTupleValues and its helper. 818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TransformTupleValuesHelper hides the internal machinery that 820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TransformTupleValues uses to implement a tuple traversal. 821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Tuple, typename Func, typename OutIter> 822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TransformTupleValuesHelper { 823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::testing::tuple_size<Tuple> TupleSize; 825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'. 828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns the final value of 'out' in case the caller needs it. 829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static OutIter Run(Func f, const Tuple& t, OutIter out) { 830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out); 831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Tup, size_t kRemainingSize> 835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch struct IterateOverTuple { 836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch OutIter operator() (Func f, const Tup& t, OutIter out) const { 837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t)); 838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out); 839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Tup> 842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch struct IterateOverTuple<Tup, 0> { 843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const { 844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return out; 845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Successively invokes 'f(element)' on each element of the tuple 't', 850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// appending each result to the 'out' iterator. Returns the final value 851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of 'out'. 852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Tuple, typename Func, typename OutIter> 853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochOutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) { 854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out); 855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements A<T>(). 858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass AnyMatcherImpl : public MatcherInterface<T> { 860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain( 862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch T /* x */, MatchResultListener* /* listener */) const { return true; } 863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; } 864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is mostly for completeness' safe, as it's not very useful 866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to write Not(A<bool>()). However we cannot completely rule out 867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // such a possibility, and it doesn't hurt to be prepared. 868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "never matches"; 869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements _, a matcher that matches any value of any 873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type. This is a polymorphic matcher, so we need a template type 874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// conversion operator to make it appearing as a Matcher<T> for any 875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type T. 876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass AnythingMatcher { 877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { return A<T>(); } 880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements a matcher that compares a given value with a 883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// pre-supplied value using one of the ==, <=, <, etc, operators. The 884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// two values being compared don't have to have the same type. 885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The matcher defined here is polymorphic (for example, Eq(5) can be 887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// used to match an int, a short, a double, etc). Therefore we use 888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a template type conversion operator in the implementation. 889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The following template definition assumes that the Rhs parameter is 891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a "bare" type (i.e. neither 'const T' nor 'T&'). 892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename D, typename Rhs, typename Op> 893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ComparisonBase { 894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {} 896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Lhs> 897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Lhs>() const { 898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<Lhs>(rhs_)); 899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Lhs> 903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<Lhs> { 904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Impl(const Rhs& rhs) : rhs_(rhs) {} 906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain( 907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Lhs lhs, MatchResultListener* /* listener */) const { 908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Op()(lhs, rhs_); 909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << D::Desc() << " "; 912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(rhs_, os); 913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << D::NegatedDesc() << " "; 916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(rhs_, os); 917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Rhs rhs_; 920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Rhs rhs_; 923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ComparisonBase); 924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> { 928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit EqMatcher(const Rhs& rhs) 930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { } 931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "is equal to"; } 932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* NegatedDesc() { return "isn't equal to"; } 933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> { 936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit NeMatcher(const Rhs& rhs) 938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { } 939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "isn't equal to"; } 940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* NegatedDesc() { return "is equal to"; } 941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> { 944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit LtMatcher(const Rhs& rhs) 946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { } 947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "is <"; } 948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* NegatedDesc() { return "isn't <"; } 949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> { 952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit GtMatcher(const Rhs& rhs) 954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { } 955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "is >"; } 956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* NegatedDesc() { return "isn't >"; } 957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> { 960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit LeMatcher(const Rhs& rhs) 962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { } 963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "is <="; } 964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* NegatedDesc() { return "isn't <="; } 965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> { 968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit GeMatcher(const Rhs& rhs) 970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { } 971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "is >="; } 972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* NegatedDesc() { return "isn't >="; } 973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the polymorphic IsNull() matcher, which matches any raw or smart 976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// pointer that is NULL. 977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass IsNullMatcher { 978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Pointer> 980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const Pointer& p, 981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return p == nullptr; 984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else // GTEST_LANG_CXX11 985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return GetRawPointer(p) == NULL; 986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { *os << "is NULL"; } 990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "isn't NULL"; 992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the polymorphic NotNull() matcher, which matches any raw or smart 996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// pointer that is not NULL. 997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NotNullMatcher { 998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Pointer> 1000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const Pointer& p, 1001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 1003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return p != nullptr; 1004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else // GTEST_LANG_CXX11 1005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return GetRawPointer(p) != NULL; 1006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 1007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; } 1010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is NULL"; 1012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Ref(variable) matches any argument that is a reference to 1016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'variable'. This matcher is polymorphic as it can match any 1017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// super type of the type of 'variable'. 1018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 1019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The RefMatcher template class implements Ref(variable). It can 1020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// only be instantiated with a reference type. This prevents a user 1021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// from mistakenly using Ref(x) to match a non-reference function 1022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// argument. For example, the following will righteously cause a 1023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// compiler error: 1024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 1025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// int n; 1026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<int> m1 = Ref(n); // This won't compile. 1027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<int&> m2 = Ref(n); // This will compile. 1028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 1029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass RefMatcher; 1030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 1032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass RefMatcher<T&> { 1033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Google Mock is a generic framework and thus needs to support 1034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // mocking any function types, including those that take non-const 1035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // reference arguments. Therefore the template parameter T (and 1036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Super below) can be instantiated to either a const type or a 1037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // non-const type. 1038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // RefMatcher() takes a T& instead of const T&, as we want the 1040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // compiler to catch using Ref(const_value) as a matcher for a 1041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // non-const reference. 1042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit RefMatcher(T& x) : object_(x) {} // NOLINT 1043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Super> 1045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Super&>() const { 1046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // By passing object_ (type T&) to Impl(), which expects a Super&, 1047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // we make sure that Super is a super type of T. In particular, 1048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // this catches using Ref(const_value) as a matcher for a 1049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // non-const reference, as you cannot implicitly convert a const 1050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // reference to a non-const reference. 1051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<Super>(object_)); 1052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Super> 1056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<Super&> { 1057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Impl(Super& x) : object_(x) {} // NOLINT 1059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatchAndExplain() takes a Super& (as opposed to const Super&) 1061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // in order to match the interface MatcherInterface<Super&>. 1062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain( 1063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Super& x, MatchResultListener* listener) const { 1064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is located @" << static_cast<const void*>(&x); 1065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return &x == &object_; 1066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 1069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "references the variable "; 1070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrinter<Super&>::Print(object_, os); 1071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 1074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "does not reference the variable "; 1075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrinter<Super&>::Print(object_, os); 1076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Super& object_; 1080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 1082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 1083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch T& object_; 1085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(RefMatcher); 1087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Polymorphic helper functions for narrow and wide string matchers. 1090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) { 1091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return String::CaseInsensitiveCStringEquals(lhs, rhs); 1092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool CaseInsensitiveCStringEquals(const wchar_t* lhs, 1095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const wchar_t* rhs) { 1096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return String::CaseInsensitiveWideCStringEquals(lhs, rhs); 1097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// String comparison for narrow or wide strings that can have embedded NUL 1100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// characters. 1101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename StringType> 1102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool CaseInsensitiveStringEquals(const StringType& s1, 1103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType& s2) { 1104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Are the heads equal? 1105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) { 1106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Skip the equal heads. 1110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const typename StringType::value_type nul = 0; 1111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const size_t i1 = s1.find(nul), i2 = s2.find(nul); 1112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Are we at the end of either s1 or s2? 1114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (i1 == StringType::npos || i2 == StringType::npos) { 1115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return i1 == i2; 1116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Are the tails equal? 1119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1)); 1120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// String matchers. 1123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements equality-based string matchers like StrEq, StrCaseNe, and etc. 1125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename StringType> 1126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass StrEqualityMatcher { 1127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrEqualityMatcher(const StringType& str, bool expect_eq, 1129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool case_sensitive) 1130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {} 1131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Accepts pointer types, particularly: 1133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const char* 1134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // char* 1135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const wchar_t* 1136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // wchar_t* 1137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename CharType> 1138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { 1139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (s == NULL) { 1140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return !expect_eq_; 1141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchAndExplain(StringType(s), listener); 1143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matches anything that can convert to StringType. 1146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is a template, not just a plain function with const StringType&, 1148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // because StringPiece has some interfering non-explicit constructors. 1149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcheeStringType> 1150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const MatcheeStringType& s, 1151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType& s2(s); 1153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool eq = case_sensitive_ ? s2 == string_ : 1154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CaseInsensitiveStringEquals(s2, string_); 1155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return expect_eq_ == eq; 1156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 1159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeToHelper(expect_eq_, os); 1160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeToHelper(!expect_eq_, os); 1164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeToHelper(bool expect_eq, ::std::ostream* os) const { 1168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << (expect_eq ? "is " : "isn't "); 1169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "equal to "; 1170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!case_sensitive_) { 1171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "(ignoring case) "; 1172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(string_, os); 1174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType string_; 1177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool expect_eq_; 1178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool case_sensitive_; 1179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher); 1181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the polymorphic HasSubstr(substring) matcher, which 1184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can be used as a Matcher<T> as long as T can be converted to a 1185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// string. 1186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename StringType> 1187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass HasSubstrMatcher { 1188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit HasSubstrMatcher(const StringType& substring) 1190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : substring_(substring) {} 1191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Accepts pointer types, particularly: 1193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const char* 1194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // char* 1195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const wchar_t* 1196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // wchar_t* 1197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename CharType> 1198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { 1199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s != NULL && MatchAndExplain(StringType(s), listener); 1200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matches anything that can convert to StringType. 1203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is a template, not just a plain function with const StringType&, 1205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // because StringPiece has some interfering non-explicit constructors. 1206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcheeStringType> 1207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const MatcheeStringType& s, 1208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType& s2(s); 1210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s2.find(substring_) != StringType::npos; 1211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher matches. 1214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 1215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has substring "; 1216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(substring_, os); 1217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has no substring "; 1221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(substring_, os); 1222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType substring_; 1226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher); 1228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the polymorphic StartsWith(substring) matcher, which 1231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can be used as a Matcher<T> as long as T can be converted to a 1232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// string. 1233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename StringType> 1234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass StartsWithMatcher { 1235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) { 1237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Accepts pointer types, particularly: 1240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const char* 1241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // char* 1242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const wchar_t* 1243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // wchar_t* 1244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename CharType> 1245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { 1246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s != NULL && MatchAndExplain(StringType(s), listener); 1247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matches anything that can convert to StringType. 1250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is a template, not just a plain function with const StringType&, 1252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // because StringPiece has some interfering non-explicit constructors. 1253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcheeStringType> 1254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const MatcheeStringType& s, 1255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType& s2(s); 1257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s2.length() >= prefix_.length() && 1258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s2.substr(0, prefix_.length()) == prefix_; 1259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 1262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "starts with "; 1263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(prefix_, os); 1264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't start with "; 1268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(prefix_, os); 1269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType prefix_; 1273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(StartsWithMatcher); 1275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the polymorphic EndsWith(substring) matcher, which 1278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can be used as a Matcher<T> as long as T can be converted to a 1279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// string. 1280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename StringType> 1281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EndsWithMatcher { 1282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {} 1284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Accepts pointer types, particularly: 1286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const char* 1287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // char* 1288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const wchar_t* 1289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // wchar_t* 1290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename CharType> 1291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { 1292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s != NULL && MatchAndExplain(StringType(s), listener); 1293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matches anything that can convert to StringType. 1296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is a template, not just a plain function with const StringType&, 1298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // because StringPiece has some interfering non-explicit constructors. 1299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename MatcheeStringType> 1300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const MatcheeStringType& s, 1301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType& s2(s); 1303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s2.length() >= suffix_.length() && 1304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s2.substr(s2.length() - suffix_.length()) == suffix_; 1305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 1308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "ends with "; 1309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(suffix_, os); 1310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't end with "; 1314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(suffix_, os); 1315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StringType suffix_; 1319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(EndsWithMatcher); 1321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements polymorphic matchers MatchesRegex(regex) and 1324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ContainsRegex(regex), which can be used as a Matcher<T> as long as 1325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T can be converted to a string. 1326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatchesRegexMatcher { 1327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchesRegexMatcher(const RE* regex, bool full_match) 1329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : regex_(regex), full_match_(full_match) {} 1330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Accepts pointer types, particularly: 1332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const char* 1333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // char* 1334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // const wchar_t* 1335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // wchar_t* 1336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename CharType> 1337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { 1338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return s != NULL && MatchAndExplain(internal::string(s), listener); 1339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matches anything that can convert to internal::string. 1342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is a template, not just a plain function with const internal::string&, 1344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // because StringPiece has some interfering non-explicit constructors. 1345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <class MatcheeStringType> 1346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const MatcheeStringType& s, 1347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string& s2(s); 1349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return full_match_ ? RE::FullMatch(s2, *regex_) : 1350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RE::PartialMatch(s2, *regex_); 1351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 1354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << (full_match_ ? "matches" : "contains") 1355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " regular expression "; 1356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrinter<internal::string>::Print(regex_->pattern(), os); 1357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't " << (full_match_ ? "match" : "contain") 1361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " regular expression "; 1362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrinter<internal::string>::Print(regex_->pattern(), os); 1363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::linked_ptr<const RE> regex_; 1367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool full_match_; 1368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher); 1370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements a matcher that compares the two fields of a 2-tuple 1373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// using one of the ==, <=, <, etc, operators. The two fields being 1374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// compared don't have to have the same type. 1375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 1376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The matcher defined here is polymorphic (for example, Eq() can be 1377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// used to match a tuple<int, short>, a tuple<const long&, double>, 1378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// etc). Therefore we use a template type conversion operator in the 1379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// implementation. 1380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename D, typename Op> 1381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PairMatchBase { 1382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T1, typename T2> 1384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher< ::testing::tuple<T1, T2> >() const { 1385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >); 1386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T1, typename T2> 1388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<const ::testing::tuple<T1, T2>&>() const { 1389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>); 1390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT 1394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return os << D::Desc(); 1395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Tuple> 1398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<Tuple> { 1399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain( 1401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Tuple args, 1402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Op()(::testing::get<0>(args), ::testing::get<1>(args)); 1404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 1406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "are " << GetDesc; 1407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 1409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "aren't " << GetDesc; 1410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 1412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> { 1415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "an equal pair"; } 1417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> { 1419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "an unequal pair"; } 1421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> { 1423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "a pair where the first < the second"; } 1425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> { 1427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "a pair where the first > the second"; } 1429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> { 1431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "a pair where the first <= the second"; } 1433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> { 1435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const char* Desc() { return "a pair where the first >= the second"; } 1437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the Not(...) matcher for a particular argument type T. 1440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We do not nest it inside the NotMatcher class template, as that 1441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// will prevent different instantiations of NotMatcher from sharing 1442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the same NotMatcherImpl<T> class. 1443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 1444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NotMatcherImpl : public MatcherInterface<T> { 1445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit NotMatcherImpl(const Matcher<T>& matcher) 1447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher_(matcher) {} 1448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { 1450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return !matcher_.MatchAndExplain(x, listener); 1451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 1454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeNegationTo(os); 1455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 1458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 1459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<T> matcher_; 1463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(NotMatcherImpl); 1465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the Not(m) matcher, which matches a value that doesn't 1468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// match matcher m. 1469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename InnerMatcher> 1470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NotMatcher { 1471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {} 1473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This template type conversion operator allows Not(m) to be used 1475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to match any type m can match. 1476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 1478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_))); 1479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch InnerMatcher matcher_; 1483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(NotMatcher); 1485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the AllOf(m1, m2) matcher for a particular argument type 1488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T. We do not nest it inside the BothOfMatcher class template, as 1489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that will prevent different instantiations of BothOfMatcher from 1490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// sharing the same BothOfMatcherImpl<T> class. 1491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 1492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BothOfMatcherImpl : public MatcherInterface<T> { 1493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2) 1495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher1_(matcher1), matcher2_(matcher2) {} 1496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 1498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "("; 1499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher1_.DescribeTo(os); 1500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ") and ("; 1501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher2_.DescribeTo(os); 1502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ")"; 1503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 1506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "("; 1507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher1_.DescribeNegationTo(os); 1508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ") or ("; 1509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher2_.DescribeNegationTo(os); 1510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ")"; 1511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { 1514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If either matcher1_ or matcher2_ doesn't match x, we only need 1515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to explain why one of them fails. 1516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener1; 1517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!matcher1_.MatchAndExplain(x, &listener1)) { 1518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << listener1.str(); 1519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener2; 1523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!matcher2_.MatchAndExplain(x, &listener2)) { 1524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << listener2.str(); 1525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Otherwise we need to explain why *both* of them match. 1529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string s1 = listener1.str(); 1530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string s2 = listener2.str(); 1531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (s1 == "") { 1533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << s2; 1534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << s1; 1536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (s2 != "") { 1537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ", and " << s2; 1538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 1541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<T> matcher1_; 1545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<T> matcher2_; 1546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl); 1548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 1551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherList provides mechanisms for storing a variable number of matchers in 1552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a list structure (ListType) and creating a combining matcher from such a 1553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// list. 1554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The template is defined recursively using the following template paramters: 1555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * kSize is the length of the MatcherList. 1556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Head is the type of the first matcher of the list. 1557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * Tail denotes the types of the remaining matchers of the list. 1558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <int kSize, typename Head, typename... Tail> 1559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct MatcherList { 1560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef MatcherList<kSize - 1, Tail...> MatcherListTail; 1561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::pair<Head, typename MatcherListTail::ListType> ListType; 1562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // BuildList stores variadic type values in a nested pair structure. 1564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Example: 1565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return 1566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the corresponding result of type pair<int, pair<string, float>>. 1567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static ListType BuildList(const Head& matcher, const Tail&... tail) { 1568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ListType(matcher, MatcherListTail::BuildList(tail...)); 1569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built 1572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the 1573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // list. CombiningMatcher<T> must implement MatcherInterface<T> and have a 1574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // constructor taking two Matcher<T>s as input. 1575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T, template <typename /* T */> class CombiningMatcher> 1576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> CreateMatcher(const ListType& matchers) { 1577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new CombiningMatcher<T>( 1578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SafeMatcherCast<T>(matchers.first), 1579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherListTail::template CreateMatcher<T, CombiningMatcher>( 1580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers.second))); 1581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The following defines the base case for the recursive definition of 1585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherList. 1586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Matcher1, typename Matcher2> 1587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct MatcherList<2, Matcher1, Matcher2> { 1588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::pair<Matcher1, Matcher2> ListType; 1589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static ListType BuildList(const Matcher1& matcher1, 1591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher2& matcher2) { 1592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ::std::pair<Matcher1, Matcher2>(matcher1, matcher2); 1593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T, template <typename /* T */> class CombiningMatcher> 1596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Matcher<T> CreateMatcher(const ListType& matchers) { 1597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new CombiningMatcher<T>( 1598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SafeMatcherCast<T>(matchers.first), 1599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SafeMatcherCast<T>(matchers.second))); 1600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// VariadicMatcher is used for the variadic implementation of 1604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...). 1605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// CombiningMatcher<T> is used to recursively combine the provided matchers 1606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (of type Args...). 1607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <template <typename T> class CombiningMatcher, typename... Args> 1608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass VariadicMatcher { 1609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch VariadicMatcher(const Args&... matchers) // NOLINT 1611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matchers_(MatcherListType::BuildList(matchers...)) {} 1612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This template type conversion operator allows an 1614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // VariadicMatcher<Matcher1, Matcher2...> object to match any type that 1615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // all of the provided matchers (Matcher1, Matcher2, ...) can match. 1616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 1618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatcherListType::template CreateMatcher<T, CombiningMatcher>( 1619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_); 1620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef MatcherList<sizeof...(Args), Args...> MatcherListType; 1624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const typename MatcherListType::ListType matchers_; 1626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(VariadicMatcher); 1628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename... Args> 1631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing AllOfMatcher = VariadicMatcher<BothOfMatcherImpl, Args...>; 1632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 1634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Used for implementing the AllOf(m_1, ..., m_n) matcher, which 1636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches a value that matches all of the matchers m_1, ..., and m_n. 1637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Matcher1, typename Matcher2> 1638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BothOfMatcher { 1639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2) 1641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher1_(matcher1), matcher2_(matcher2) {} 1642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This template type conversion operator allows a 1644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // BothOfMatcher<Matcher1, Matcher2> object to match any type that 1645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // both Matcher1 and Matcher2 can match. 1646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 1648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_), 1649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SafeMatcherCast<T>(matcher2_))); 1650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher1 matcher1_; 1654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher2 matcher2_; 1655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(BothOfMatcher); 1657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the AnyOf(m1, m2) matcher for a particular argument type 1660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T. We do not nest it inside the AnyOfMatcher class template, as 1661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that will prevent different instantiations of AnyOfMatcher from 1662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// sharing the same EitherOfMatcherImpl<T> class. 1663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 1664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EitherOfMatcherImpl : public MatcherInterface<T> { 1665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2) 1667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher1_(matcher1), matcher2_(matcher2) {} 1668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 1670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "("; 1671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher1_.DescribeTo(os); 1672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ") or ("; 1673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher2_.DescribeTo(os); 1674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ")"; 1675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 1678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "("; 1679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher1_.DescribeNegationTo(os); 1680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ") and ("; 1681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher2_.DescribeNegationTo(os); 1682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ")"; 1683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { 1686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If either matcher1_ or matcher2_ matches x, we just need to 1687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain why *one* of them matches. 1688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener1; 1689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (matcher1_.MatchAndExplain(x, &listener1)) { 1690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << listener1.str(); 1691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 1692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener2; 1695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (matcher2_.MatchAndExplain(x, &listener2)) { 1696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << listener2.str(); 1697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 1698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Otherwise we need to explain why *both* of them fail. 1701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string s1 = listener1.str(); 1702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string s2 = listener2.str(); 1703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (s1 == "") { 1705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << s2; 1706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << s1; 1708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (s2 != "") { 1709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ", and " << s2; 1710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<T> matcher1_; 1717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<T> matcher2_; 1718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl); 1720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 1723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...). 1724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename... Args> 1725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl, Args...>; 1726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 1728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Used for implementing the AnyOf(m_1, ..., m_n) matcher, which 1730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches a value that matches at least one of the matchers m_1, ..., 1731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and m_n. 1732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Matcher1, typename Matcher2> 1733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EitherOfMatcher { 1734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2) 1736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher1_(matcher1), matcher2_(matcher2) {} 1737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This template type conversion operator allows a 1739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // EitherOfMatcher<Matcher1, Matcher2> object to match any type that 1740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // both Matcher1 and Matcher2 can match. 1741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 1743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new EitherOfMatcherImpl<T>( 1744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_))); 1745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher1 matcher1_; 1749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher2 matcher2_; 1750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(EitherOfMatcher); 1752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Used for implementing Truly(pred), which turns a predicate into a 1755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher. 1756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Predicate> 1757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass TrulyMatcher { 1758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit TrulyMatcher(Predicate pred) : predicate_(pred) {} 1760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This method template allows Truly(pred) to be used as a matcher 1762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // for type T where T is the argument type of predicate 'pred'. The 1763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // argument is passed by reference as the predicate may be 1764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // interested in the address of the argument. 1765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(T& x, // NOLINT 1767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 1768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Without the if-statement, MSVC sometimes warns about converting 1769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a value to bool (warning 4800). 1770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We cannot write 'return !!predicate_(x);' as that doesn't work 1772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // when predicate_(x) returns a class convertible to bool but 1773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // having no operator!(). 1774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (predicate_(x)) 1775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 1776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 1780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "satisfies the given predicate"; 1781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 1784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't satisfy the given predicate"; 1785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Predicate predicate_; 1789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(TrulyMatcher); 1791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Used for implementing Matches(matcher), which turns a matcher into 1794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a predicate. 1795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 1796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass MatcherAsPredicate { 1797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {} 1799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This template operator() allows Matches(m) to be used as a 1801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // predicate on type T where m is a matcher on type T. 1802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The argument x is passed by reference instead of by value, as 1804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // some matcher may be interested in its address (e.g. as in 1805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matches(Ref(n))(x)). 1806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const T& x) const { 1808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We let matcher_ commit to a particular type here instead of 1809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // when the MatcherAsPredicate object was constructed. This 1810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // allows us to write Matches(m) where m is a polymorphic matcher 1811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // (e.g. Eq(5)). 1812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If we write Matcher<T>(matcher_).Matches(x) here, it won't 1814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // compile when matcher_ has type Matcher<const T&>; if we write 1815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matcher<const T&>(matcher_).Matches(x) here, it won't compile 1816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // when matcher_ has type Matcher<T>; if we just write 1817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_.Matches(x), it won't compile when matcher_ is 1818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // polymorphic, e.g. Eq(5). 1819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatcherCast<const T&>() is necessary for making the code work 1821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // in all of the above situations. 1822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatcherCast<const T&>(matcher_).Matches(x); 1823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch M matcher_; 1827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate); 1829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For implementing ASSERT_THAT() and EXPECT_THAT(). The template 1832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// argument M must be a type that can be converted to a matcher. 1833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 1834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PredicateFormatterFromMatcher { 1835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {} 1837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This template () operator allows a PredicateFormatterFromMatcher 1839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // object to act as a predicate-formatter suitable for using with 1840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Google Test's EXPECT_PRED_FORMAT1() macro. 1841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AssertionResult operator()(const char* value_text, const T& x) const { 1843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We convert matcher_ to a Matcher<const T&> *now* instead of 1844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // when the PredicateFormatterFromMatcher object was constructed, 1845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // as matcher_ may be polymorphic (e.g. NotNull()) and we won't 1846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // know which type to instantiate it to until we actually see the 1847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // type of x here. 1848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We write SafeMatcherCast<const T&>(matcher_) instead of 1850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matcher<const T&>(matcher_), as the latter won't compile when 1851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_ has type Matcher<T> (e.g. An<int>()). 1852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We don't write MatcherCast<const T&> either, as that allows 1853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // potentially unsafe downcasting of the matcher argument. 1854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_); 1855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 1856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (MatchPrintAndExplain(x, matcher, &listener)) 1857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return AssertionSuccess(); 1858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::stringstream ss; 1860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ss << "Value of: " << value_text << "\n" 1861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "Expected: "; 1862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher.DescribeTo(&ss); 1863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ss << "\n Actual: " << listener.str(); 1864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return AssertionFailure() << ss.str(); 1865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const M matcher_; 1869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher); 1871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 1872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A helper function for converting a matcher to a predicate-formatter 1874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// without the user needing to explicitly write the type. This is 1875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// used for implementing ASSERT_THAT() and EXPECT_THAT(). 1876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implementation detail: 'matcher' is received by-value to force decaying. 1877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 1878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PredicateFormatterFromMatcher<M> 1879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMakePredicateFormatterFromMatcher(M matcher) { 1880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return PredicateFormatterFromMatcher<M>(internal::move(matcher)); 1881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the polymorphic floating point equality matcher, which matches 1884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// two float values using ULP-based approximation or, optionally, a 1885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// user-specified epsilon. The template is meant to be instantiated with 1886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// FloatType being either float or double. 1887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename FloatType> 1888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass FloatingEqMatcher { 1889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructor for FloatingEqMatcher. 1891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The matcher's input will be compared with expected. The matcher treats two 1892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NANs as equal if nan_eq_nan is true. Otherwise, under IEEE standards, 1893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // equality comparisons between NANs will always return false. We specify a 1894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // negative max_abs_error_ term to indicate that ULP-based approximation will 1895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // be used for comparison. 1896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FloatingEqMatcher(FloatType expected, bool nan_eq_nan) : 1897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) { 1898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructor that supports a user-specified max_abs_error that will be used 1901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // for comparison instead of ULP-based approximation. The max absolute 1902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // should be non-negative. 1903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FloatingEqMatcher(FloatType expected, bool nan_eq_nan, 1904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FloatType max_abs_error) 1905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : expected_(expected), 1906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch nan_eq_nan_(nan_eq_nan), 1907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch max_abs_error_(max_abs_error) { 1908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CHECK_(max_abs_error >= 0) 1909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << ", where max_abs_error is" << max_abs_error; 1910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Implements floating point equality matcher as a Matcher<T>. 1913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 1914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<T> { 1915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 1916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error) 1917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : expected_(expected), 1918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch nan_eq_nan_(nan_eq_nan), 1919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch max_abs_error_(max_abs_error) {} 1920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T value, 1922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 1923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FloatingPoint<FloatType> actual(value), expected(expected_); 1924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Compares NaNs first, if nan_eq_nan_ is true. 1926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual.is_nan() || expected.is_nan()) { 1927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual.is_nan() && expected.is_nan()) { 1928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return nan_eq_nan_; 1929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // One is nan; the other is not nan. 1931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (HasMaxAbsError()) { 1934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We perform an equality check so that inf will match inf, regardless 1935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // of error bounds. If the result of value - expected_ would result in 1936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // overflow or if either value is inf, the default result is infinity, 1937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which should only match if max_abs_error_ is also infinity. 1938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (value == expected_) { 1939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 1940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FloatType diff = value - expected_; 1943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (fabs(diff) <= max_abs_error_) { 1944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 1945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener->IsInterested()) { 1948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is " << diff << " from " << expected_; 1949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 1951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return actual.AlmostEquals(expected); 1953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 1957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // os->precision() returns the previously set precision, which we 1958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // store to restore the ostream to its original configuration 1959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // after outputting. 1960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ::std::streamsize old_precision = os->precision( 1961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::numeric_limits<FloatType>::digits10 + 2); 1962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (FloatingPoint<FloatType>(expected_).is_nan()) { 1963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (nan_eq_nan_) { 1964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is NaN"; 1965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "never matches"; 1967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is approximately " << expected_; 1970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (HasMaxAbsError()) { 1971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << " (absolute error <= " << max_abs_error_ << ")"; 1972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch os->precision(old_precision); 1975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 1978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // As before, get original precision. 1979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ::std::streamsize old_precision = os->precision( 1980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::numeric_limits<FloatType>::digits10 + 2); 1981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (FloatingPoint<FloatType>(expected_).is_nan()) { 1982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (nan_eq_nan_) { 1983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "isn't NaN"; 1984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is anything"; 1986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 1988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "isn't approximately " << expected_; 1989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (HasMaxAbsError()) { 1990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << " (absolute error > " << max_abs_error_ << ")"; 1991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Restore original precision. 1994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch os->precision(old_precision); 1995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 1996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 1998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool HasMaxAbsError() const { 1999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return max_abs_error_ >= 0; 2000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FloatType expected_; 2003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool nan_eq_nan_; 2004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // max_abs_error will be used for value comparison when >= 0. 2005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FloatType max_abs_error_; 2006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 2008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 2009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The following 3 type conversion operators allow FloatEq(expected) and 2011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a 2012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matcher<const float&>, or a Matcher<float&>, but nothing else. 2013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // (While Google's C++ coding style doesn't allow arguments passed 2014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // by non-const reference, we may see them in code not conforming to 2015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the style. Therefore Google Mock needs to support them.) 2016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<FloatType>() const { 2017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher( 2018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_)); 2019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<const FloatType&>() const { 2022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher( 2023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_)); 2024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<FloatType&>() const { 2027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher( 2028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_)); 2029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FloatType expected_; 2033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool nan_eq_nan_; 2034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // max_abs_error will be used for value comparison when >= 0. 2035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FloatType max_abs_error_; 2036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher); 2038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the Pointee(m) matcher for matching a pointer whose 2041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// pointee matches matcher m. The pointer can be either raw or smart. 2042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename InnerMatcher> 2043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PointeeMatcher { 2044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {} 2046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This type conversion operator template allows Pointee(m) to be 2048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // used as a matcher for any pointer type whose pointee type is 2049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // compatible with the inner matcher, where type Pointer can be 2050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // either a raw pointer or a smart pointer. 2051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 2052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The reason we do this instead of relying on 2053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MakePolymorphicMatcher() is that the latter is not flexible 2054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // enough for implementing the DescribeTo() method of Pointee(). 2055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Pointer> 2056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Pointer>() const { 2057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<Pointer>(matcher_)); 2058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The monomorphic implementation that works for a particular pointer type. 2062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Pointer> 2063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<Pointer> { 2064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename PointeeOf<GTEST_REMOVE_CONST_( // NOLINT 2066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee; 2067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Impl(const InnerMatcher& matcher) 2069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher_(MatcherCast<const Pointee&>(matcher)) {} 2070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "points to a value that "; 2073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "does not point to a value that "; 2078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Pointer pointer, 2082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (GetRawPointer(pointer) == NULL) 2084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which points to "; 2087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchPrintAndExplain(*pointer, matcher_, listener); 2088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const Pointee&> matcher_; 2092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 2094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 2095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const InnerMatcher matcher_; 2097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PointeeMatcher); 2099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or 2102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// reference that matches inner_matcher when dynamic_cast<T> is applied. 2103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The result of dynamic_cast<To> is forwarded to the inner matcher. 2104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If To is a pointer and the cast fails, the inner matcher will receive NULL. 2105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If To is a reference and the cast fails, this matcher returns false 2106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// immediately. 2107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename To> 2108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass WhenDynamicCastToMatcherBase { 2109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher) 2111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matcher_(matcher) {} 2112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 2114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GetCastTypeDescription(os); 2115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 2119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GetCastTypeDescription(os); 2120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeNegationTo(os); 2121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 2124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<To> matcher_; 2125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static string GetToName() { 2127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_RTTI 2128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return GetTypeName<To>(); 2129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else // GTEST_HAS_RTTI 2130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return "the target type"; 2131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_RTTI 2132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void GetCastTypeDescription(::std::ostream* os) { 2136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "when dynamic_cast to " << GetToName() << ", "; 2137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(WhenDynamicCastToMatcherBase); 2140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Primary template. 2143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// To is a pointer. Cast and forward the result. 2144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename To> 2145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> { 2146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher) 2148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : WhenDynamicCastToMatcherBase<To>(matcher) {} 2149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename From> 2151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(From from, MatchResultListener* listener) const { 2152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // TODO(sbenza): Add more detail on failures. ie did the dyn_cast fail? 2153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch To to = dynamic_cast<To>(from); 2154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchPrintAndExplain(to, this->matcher_, listener); 2155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Specialize for references. 2159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// In this case we return false if the dynamic_cast fails. 2160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename To> 2161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> { 2162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher) 2164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : WhenDynamicCastToMatcherBase<To&>(matcher) {} 2165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename From> 2167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(From& from, MatchResultListener* listener) const { 2168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We don't want an std::bad_cast here, so do the cast with pointers. 2169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch To* to = dynamic_cast<To*>(&from); 2170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (to == NULL) { 2171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which cannot be dynamic_cast to " << this->GetToName(); 2172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchPrintAndExplain(*to, this->matcher_, listener); 2175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the Field() matcher for matching a field (i.e. member 2179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// variable) of an object. 2180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Class, typename FieldType> 2181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass FieldMatcher { 2182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FieldMatcher(FieldType Class::*field, 2184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const FieldType&>& matcher) 2185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : field_(field), matcher_(matcher) {} 2186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 2188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is an object whose given field "; 2189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 2193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is an object whose given field "; 2194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeNegationTo(os); 2195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 2198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const T& value, MatchResultListener* listener) const { 2199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchAndExplainImpl( 2200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::testing::internal:: 2201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch is_pointer<GTEST_REMOVE_CONST_(T)>::type(), 2202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch value, listener); 2203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The first argument of MatchAndExplainImpl() is needed to help 2207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Symbian's C++ compiler choose which overload to use. Its type is 2208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // true_type iff the Field() matcher is used to match a pointer. 2209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj, 2210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose given field is "; 2212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchPrintAndExplain(obj.*field_, matcher_, listener); 2213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p, 2216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (p == NULL) 2218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which points to an object "; 2221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Since *p has a field, it must be a class/struct/union type and 2222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // thus cannot be a pointer. Therefore we pass false_type() as 2223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the first argument. 2224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchAndExplainImpl(false_type(), *p, listener); 2225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FieldType Class::*field_; 2228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const FieldType&> matcher_; 2229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(FieldMatcher); 2231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the Property() matcher for matching a property 2234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (i.e. return value of a getter method) of an object. 2235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Class, typename PropertyType> 2236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PropertyMatcher { 2237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The property may have a reference type, so 'const PropertyType&' 2239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // may cause double references and fail to compile. That's why we 2240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // need GTEST_REFERENCE_TO_CONST, which works regardless of 2241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // PropertyType being a reference or not. 2242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty; 2243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PropertyMatcher(PropertyType (Class::*property)() const, 2245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<RefToConstProperty>& matcher) 2246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : property_(property), matcher_(matcher) {} 2247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 2249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is an object whose given property "; 2250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 2254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is an object whose given property "; 2255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeNegationTo(os); 2256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 2259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const T&value, MatchResultListener* listener) const { 2260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchAndExplainImpl( 2261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::testing::internal:: 2262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch is_pointer<GTEST_REMOVE_CONST_(T)>::type(), 2263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch value, listener); 2264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The first argument of MatchAndExplainImpl() is needed to help 2268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Symbian's C++ compiler choose which overload to use. Its type is 2269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // true_type iff the Property() matcher is used to match a pointer. 2270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj, 2271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose given property is "; 2273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Cannot pass the return value (for example, int) to MatchPrintAndExplain, 2274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which takes a non-const reference as argument. 2275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if defined(_PREFAST_ ) && _MSC_VER == 1800 2276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Workaround bug in VC++ 2013's /analyze parser. 2277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move 2278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch posix::Abort(); // To make sure it is never run. 2279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else 2281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RefToConstProperty result = (obj.*property_)(); 2282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchPrintAndExplain(result, matcher_, listener); 2283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 2284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p, 2287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (p == NULL) 2289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which points to an object "; 2292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Since *p has a property method, it must be a class/struct/union 2293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // type and thus cannot be a pointer. Therefore we pass 2294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // false_type() as the first argument. 2295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchAndExplainImpl(false_type(), *p, listener); 2296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PropertyType (Class::*property_)() const; 2299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<RefToConstProperty> matcher_; 2300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PropertyMatcher); 2302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Type traits specifying various features of different functors for ResultOf. 2305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The default template specifies features for functor objects. 2306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Functor classes have to typedef argument_type and result_type 2307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// to be compatible with ResultOf. 2308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Functor> 2309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct CallableTraits { 2310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename Functor::result_type ResultType; 2311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef Functor StorageType; 2312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void CheckIsValid(Functor /* functor */) {} 2314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 2315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static ResultType Invoke(Functor f, T arg) { return f(arg); } 2316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Specialization for function pointers. 2319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename ArgType, typename ResType> 2320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct CallableTraits<ResType(*)(ArgType)> { 2321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ResType ResultType; 2322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ResType(*StorageType)(ArgType); 2323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void CheckIsValid(ResType(*f)(ArgType)) { 2325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_CHECK_(f != NULL) 2326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "NULL function pointer is passed into ResultOf()."; 2327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 2329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static ResType Invoke(ResType(*f)(ArgType), T arg) { 2330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (*f)(arg); 2331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements the ResultOf() matcher for matching a return value of a 2335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// unary function of an object. 2336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Callable> 2337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ResultOfMatcher { 2338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename CallableTraits<Callable>::ResultType ResultType; 2340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ResultOfMatcher(Callable callable, const Matcher<ResultType>& matcher) 2342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : callable_(callable), matcher_(matcher) { 2343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CallableTraits<Callable>::CheckIsValid(callable_); 2344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 2347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 2348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Matcher<T>(new Impl<T>(callable_, matcher_)); 2349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename CallableTraits<Callable>::StorageType CallableStorageType; 2353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 2355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<T> { 2356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl(CallableStorageType callable, const Matcher<ResultType>& matcher) 2358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : callable_(callable), matcher_(matcher) {} 2359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is mapped by the given callable to a value that "; 2362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is mapped by the given callable to a value that "; 2367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeNegationTo(os); 2368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T obj, MatchResultListener* listener) const { 2371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is mapped by the given callable to "; 2372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Cannot pass the return value (for example, int) to 2373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatchPrintAndExplain, which takes a non-const reference as argument. 2374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ResultType result = 2375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch CallableTraits<Callable>::template Invoke<T>(callable_, obj); 2376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchPrintAndExplain(result, matcher_, listener); 2377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Functors often define operator() as non-const method even though 2381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // they are actualy stateless. But we need to use them even when 2382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 'this' is a const pointer. It's the user's responsibility not to 2383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // use stateful callables with ResultOf(), which does't guarantee 2384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // how many times the callable will be invoked. 2385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mutable CallableStorageType callable_; 2386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<ResultType> matcher_; 2387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 2389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; // class Impl 2390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const CallableStorageType callable_; 2392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<ResultType> matcher_; 2393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ResultOfMatcher); 2395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements a matcher that checks the size of an STL-style container. 2398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename SizeMatcher> 2399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass SizeIsMatcher { 2400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit SizeIsMatcher(const SizeMatcher& size_matcher) 2402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : size_matcher_(size_matcher) { 2403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 2406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 2407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<Container>(size_matcher_)); 2408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 2411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<Container> { 2412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView< 2414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView; 2415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename ContainerView::type::size_type SizeType; 2416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Impl(const SizeMatcher& size_matcher) 2417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : size_matcher_(MatcherCast<SizeType>(size_matcher)) {} 2418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "size "; 2421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_matcher_.DescribeTo(os); 2422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "size "; 2425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_matcher_.DescribeNegationTo(os); 2426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Container container, 2429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SizeType size = container.size(); 2431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener size_listener; 2432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool result = size_matcher_.MatchAndExplain(size, &size_listener); 2433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener 2434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "whose size " << size << (result ? " matches" : " doesn't match"); 2435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(size_listener.str(), listener->stream()); 2436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return result; 2437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<SizeType> size_matcher_; 2441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 2442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 2443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const SizeMatcher size_matcher_; 2446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(SizeIsMatcher); 2447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements a matcher that checks the begin()..end() distance of an STL-style 2450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// container. 2451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename DistanceMatcher> 2452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BeginEndDistanceIsMatcher { 2453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher) 2455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : distance_matcher_(distance_matcher) {} 2456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 2458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 2459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<Container>(distance_matcher_)); 2460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 2463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<Container> { 2464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView< 2466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView; 2467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename std::iterator_traits< 2468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ContainerView::type::const_iterator>::difference_type 2469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DistanceType; 2470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Impl(const DistanceMatcher& distance_matcher) 2471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {} 2472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "distance between begin() and end() "; 2475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch distance_matcher_.DescribeTo(os); 2476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "distance between begin() and end() "; 2479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch distance_matcher_.DescribeNegationTo(os); 2480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Container container, 2483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_BEGIN_AND_END_ 2485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch using std::begin; 2486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch using std::end; 2487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DistanceType distance = std::distance(begin(container), end(container)); 2488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else 2489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DistanceType distance = std::distance(container.begin(), container.end()); 2490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 2491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener distance_listener; 2492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool result = 2493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch distance_matcher_.MatchAndExplain(distance, &distance_listener); 2494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose distance between begin() and end() " << distance 2495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << (result ? " matches" : " doesn't match"); 2496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(distance_listener.str(), listener->stream()); 2497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return result; 2498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<DistanceType> distance_matcher_; 2502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 2503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 2504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const DistanceMatcher distance_matcher_; 2507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(BeginEndDistanceIsMatcher); 2508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements an equality matcher for any STL-style container whose elements 2511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// support ==. This matcher is like Eq(), but its failure explanations provide 2512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// more detailed information that is useful when the container is used as a set. 2513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The failure message reports elements that are in one of the operands but not 2514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the other. The failure messages do not report duplicate or out-of-order 2515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// elements in the containers (which don't properly matter to sets, but can 2516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// occur if the containers are vectors or lists, for example). 2517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 2518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Uses the container's const_iterator, value_type, operator ==, 2519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// begin(), and end(). 2520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 2521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ContainerEqMatcher { 2522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView<Container> View; 2524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::type StlContainer; 2525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::const_reference StlContainerReference; 2526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We make a copy of expected in case the elements in it are modified 2528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // after this matcher is created. 2529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ContainerEqMatcher(const Container& expected) 2530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : expected_(View::Copy(expected)) { 2531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Makes sure the user doesn't instantiate this class template 2532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // with a const or reference type. 2533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (void)testing::StaticAssertTypeEq<Container, 2534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>(); 2535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(::std::ostream* os) const { 2538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "equals "; 2539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(expected_, os); 2540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(::std::ostream* os) const { 2542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "does not equal "; 2543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(expected_, os); 2544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename LhsContainer> 2547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const LhsContainer& lhs, 2548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug 2550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // that causes LhsContainer to be a const type sometimes. 2551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)> 2552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch LhsView; 2553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename LhsView::type LhsStlContainer; 2554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); 2555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (lhs_stl_container == expected_) 2556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 2557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::ostream* const os = listener->stream(); 2559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (os != NULL) { 2560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Something is different. Check for extra values first. 2561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool printed_header = false; 2562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (typename LhsStlContainer::const_iterator it = 2563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_stl_container.begin(); 2564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch it != lhs_stl_container.end(); ++it) { 2565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) == 2566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected_.end()) { 2567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (printed_header) { 2568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ", "; 2569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 2570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "which has these unexpected elements: "; 2571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch printed_header = true; 2572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(*it, os); 2574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Now check for missing values. 2578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool printed_header2 = false; 2579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (typename StlContainer::const_iterator it = expected_.begin(); 2580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch it != expected_.end(); ++it) { 2581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (internal::ArrayAwareFind( 2582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_stl_container.begin(), lhs_stl_container.end(), *it) == 2583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_stl_container.end()) { 2584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (printed_header2) { 2585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ", "; 2586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 2587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << (printed_header ? ",\nand" : "which") 2588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " doesn't have these expected elements: "; 2589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch printed_header2 = true; 2590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(*it, os); 2592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const StlContainer expected_; 2601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher); 2603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A comparator functor that uses the < operator to compare two values. 2606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct LessComparator { 2607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T, typename U> 2608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; } 2609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements WhenSortedBy(comparator, container_matcher). 2612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Comparator, typename ContainerMatcher> 2613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass WhenSortedByMatcher { 2614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch WhenSortedByMatcher(const Comparator& comparator, 2616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ContainerMatcher& matcher) 2617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : comparator_(comparator), matcher_(matcher) {} 2618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename LhsContainer> 2620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<LhsContainer>() const { 2621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_)); 2622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename LhsContainer> 2625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<LhsContainer> { 2626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView< 2628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView; 2629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename LhsView::type LhsStlContainer; 2630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename LhsView::const_reference LhsStlContainerReference; 2631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Transforms std::pair<const Key, Value> into std::pair<Key, Value> 2632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // so that we can match associative containers. 2633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RemoveConstFromKey< 2634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename LhsStlContainer::value_type>::type LhsValue; 2635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl(const Comparator& comparator, const ContainerMatcher& matcher) 2637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : comparator_(comparator), matcher_(matcher) {} 2638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "(when sorted) "; 2641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeTo(os); 2642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "(when sorted) "; 2646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_.DescribeNegationTo(os); 2647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(LhsContainer lhs, 2650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); 2652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(), 2653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_stl_container.end()); 2654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::sort( 2655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sorted_container.begin(), sorted_container.end(), comparator_); 2656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!listener->IsInterested()) { 2658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If the listener is not interested, we do not need to 2659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // construct the inner explanation. 2660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return matcher_.Matches(sorted_container); 2661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is "; 2664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(sorted_container, listener->stream()); 2665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << " when sorted"; 2666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener inner_listener; 2668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool match = matcher_.MatchAndExplain(sorted_container, 2669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch &inner_listener); 2670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(inner_listener.str(), listener->stream()); 2671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return match; 2672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Comparator comparator_; 2676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::std::vector<LhsValue>&> matcher_; 2677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl); 2679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 2680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Comparator comparator_; 2683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ContainerMatcher matcher_; 2684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(WhenSortedByMatcher); 2686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements Pointwise(tuple_matcher, rhs_container). tuple_matcher 2689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// must be able to be safely cast to Matcher<tuple<const T1&, const 2690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T2&> >, where T1 and T2 are the types of elements in the LHS 2691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// container and the RHS container respectively. 2692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename TupleMatcher, typename RhsContainer> 2693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PointwiseMatcher { 2694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView<RhsContainer> RhsView; 2696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RhsView::type RhsStlContainer; 2697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RhsStlContainer::value_type RhsValue; 2698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Like ContainerEq, we make a copy of rhs in case the elements in 2700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // it are modified after this matcher is created. 2701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs) 2702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) { 2703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Makes sure the user doesn't instantiate this class template 2704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // with a const or reference type. 2705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (void)testing::StaticAssertTypeEq<RhsContainer, 2706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>(); 2707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename LhsContainer> 2710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<LhsContainer>() const { 2711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_)); 2712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename LhsContainer> 2715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<LhsContainer> { 2716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView< 2718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView; 2719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename LhsView::type LhsStlContainer; 2720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename LhsView::const_reference LhsStlContainerReference; 2721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename LhsStlContainer::value_type LhsValue; 2722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We pass the LHS value and the RHS value to the inner matcher by 2723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // reference, as they may be expensive to copy. We must use tuple 2724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // instead of pair here, as a pair cannot hold references (C++ 98, 2725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 20.2.2 [lib.pairs]). 2726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::testing::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg; 2727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs) 2729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher. 2730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)), 2731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs_(rhs) {} 2732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "contains " << rhs_.size() 2735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " values, where each value and its corresponding value in "; 2736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrinter<RhsStlContainer>::Print(rhs_, os); 2737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << " "; 2738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mono_tuple_matcher_.DescribeTo(os); 2739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't contain exactly " << rhs_.size() 2742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " values, or contains a value x at some index i" 2743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " where x and the i-th value of "; 2744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(rhs_, os); 2745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << " "; 2746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mono_tuple_matcher_.DescribeNegationTo(os); 2747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(LhsContainer lhs, 2750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs); 2752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const size_t actual_size = lhs_stl_container.size(); 2753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual_size != rhs_.size()) { 2754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which contains " << actual_size << " values"; 2755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename LhsStlContainer::const_iterator left = lhs_stl_container.begin(); 2759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename RhsStlContainer::const_iterator right = rhs_.begin(); 2760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i != actual_size; ++i, ++left, ++right) { 2761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const InnerMatcherArg value_pair(*left, *right); 2762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener->IsInterested()) { 2764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener inner_listener; 2765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!mono_tuple_matcher_.MatchAndExplain( 2766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch value_pair, &inner_listener)) { 2767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "where the value pair ("; 2768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(*left, listener->stream()); 2769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ", "; 2770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(*right, listener->stream()); 2771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ") at index #" << i << " don't match"; 2772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(inner_listener.str(), listener->stream()); 2773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 2776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!mono_tuple_matcher_.Matches(value_pair)) 2777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 2778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 2782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<InnerMatcherArg> mono_tuple_matcher_; 2786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RhsStlContainer rhs_; 2787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 2789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 2790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const TupleMatcher tuple_matcher_; 2793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RhsStlContainer rhs_; 2794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PointwiseMatcher); 2796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl. 2799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 2800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass QuantifierMatcherImpl : public MatcherInterface<Container> { 2801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; 2803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef StlContainerView<RawContainer> View; 2804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::type StlContainer; 2805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::const_reference StlContainerReference; 2806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename StlContainer::value_type Element; 2807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InnerMatcher> 2809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit QuantifierMatcherImpl(InnerMatcher inner_matcher) 2810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : inner_matcher_( 2811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::SafeMatcherCast<const Element&>(inner_matcher)) {} 2812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Checks whether: 2814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // * All elements in the container match, if all_elements_should_match. 2815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // * Any element in the container matches, if !all_elements_should_match. 2816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplainImpl(bool all_elements_should_match, 2817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Container container, 2818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StlContainerReference stl_container = View::ConstReference(container); 2820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t i = 0; 2821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (typename StlContainer::const_iterator it = stl_container.begin(); 2822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch it != stl_container.end(); ++it, ++i) { 2823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener inner_listener; 2824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener); 2825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (matches != all_elements_should_match) { 2827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose element #" << i 2828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << (matches ? " matches" : " doesn't match"); 2829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(inner_listener.str(), listener->stream()); 2830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return !all_elements_should_match; 2831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return all_elements_should_match; 2834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 2837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const Element&> inner_matcher_; 2838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl); 2840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements Contains(element_matcher) for the given argument type Container. 2843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Symmetric to EachMatcherImpl. 2844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 2845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ContainsMatcherImpl : public QuantifierMatcherImpl<Container> { 2846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InnerMatcher> 2848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ContainsMatcherImpl(InnerMatcher inner_matcher) 2849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : QuantifierMatcherImpl<Container>(inner_matcher) {} 2850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher does. 2852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "contains at least one element that "; 2854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch this->inner_matcher_.DescribeTo(os); 2855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't contain any element that "; 2859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch this->inner_matcher_.DescribeTo(os); 2860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Container container, 2863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return this->MatchAndExplainImpl(false, container, listener); 2865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl); 2869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements Each(element_matcher) for the given argument type Container. 2872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Symmetric to ContainsMatcherImpl. 2873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 2874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EachMatcherImpl : public QuantifierMatcherImpl<Container> { 2875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InnerMatcher> 2877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit EachMatcherImpl(InnerMatcher inner_matcher) 2878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : QuantifierMatcherImpl<Container>(inner_matcher) {} 2879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher does. 2881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "only contains elements that "; 2883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch this->inner_matcher_.DescribeTo(os); 2884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "contains some element that "; 2888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch this->inner_matcher_.DescribeNegationTo(os); 2889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Container container, 2892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return this->MatchAndExplainImpl(true, container, listener); 2894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(EachMatcherImpl); 2898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements polymorphic Contains(element_matcher). 2901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 2902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ContainsMatcher { 2903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ContainsMatcher(M m) : inner_matcher_(m) {} 2905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 2907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 2908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new ContainsMatcherImpl<Container>(inner_matcher_)); 2909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const M inner_matcher_; 2913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ContainsMatcher); 2915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements polymorphic Each(element_matcher). 2918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 2919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EachMatcher { 2920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit EachMatcher(M m) : inner_matcher_(m) {} 2922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 2924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 2925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_)); 2926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const M inner_matcher_; 2930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(EachMatcher); 2932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements Key(inner_matcher) for the given argument pair type. 2935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Key(inner_matcher) matches an std::pair whose 'first' field matches 2936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an 2937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// std::map that contains at least one element whose key is >= 5. 2938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename PairType> 2939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass KeyMatcherImpl : public MatcherInterface<PairType> { 2940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType; 2942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RawPairType::first_type KeyType; 2943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InnerMatcher> 2945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit KeyMatcherImpl(InnerMatcher inner_matcher) 2946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : inner_matcher_( 2947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::SafeMatcherCast<const KeyType&>(inner_matcher)) { 2948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff 'key_value.first' (the key) matches the inner matcher. 2951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(PairType key_value, 2952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 2953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener inner_listener; 2954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool match = inner_matcher_.MatchAndExplain(key_value.first, 2955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch &inner_listener); 2956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string explanation = inner_listener.str(); 2957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (explanation != "") { 2958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose first field is a value " << explanation; 2959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return match; 2961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher does. 2964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 2965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has a key that "; 2966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch inner_matcher_.DescribeTo(os); 2967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what the negation of this matcher does. 2970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 2971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't have a key that "; 2972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch inner_matcher_.DescribeTo(os); 2973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const KeyType&> inner_matcher_; 2977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl); 2979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements polymorphic Key(matcher_for_key). 2982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 2983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass KeyMatcher { 2984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit KeyMatcher(M m) : matcher_for_key_(m) {} 2986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename PairType> 2988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<PairType>() const { 2989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_)); 2990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const M matcher_for_key_; 2994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(KeyMatcher); 2996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements Pair(first_matcher, second_matcher) for the given argument pair 2999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type with its two matchers. See Pair() function below. 3000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename PairType> 3001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PairMatcherImpl : public MatcherInterface<PairType> { 3002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType; 3004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RawPairType::first_type FirstType; 3005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RawPairType::second_type SecondType; 3006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename FirstMatcher, typename SecondMatcher> 3008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher) 3009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : first_matcher_( 3010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::SafeMatcherCast<const FirstType&>(first_matcher)), 3011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch second_matcher_( 3012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::SafeMatcherCast<const SecondType&>(second_matcher)) { 3013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher does. 3016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 3017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has a first field that "; 3018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch first_matcher_.DescribeTo(os); 3019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ", and has a second field that "; 3020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch second_matcher_.DescribeTo(os); 3021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what the negation of this matcher does. 3024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 3025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has a first field that "; 3026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch first_matcher_.DescribeNegationTo(os); 3027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ", or has a second field that "; 3028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch second_matcher_.DescribeNegationTo(os); 3029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Returns true iff 'a_pair.first' matches first_matcher and 'a_pair.second' 3032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matches second_matcher. 3033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(PairType a_pair, 3034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 3035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!listener->IsInterested()) { 3036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If the listener is not interested, we don't need to construct the 3037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explanation. 3038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return first_matcher_.Matches(a_pair.first) && 3039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch second_matcher_.Matches(a_pair.second); 3040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener first_inner_listener; 3042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!first_matcher_.MatchAndExplain(a_pair.first, 3043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch &first_inner_listener)) { 3044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose first field does not match"; 3045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(first_inner_listener.str(), listener->stream()); 3046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 3047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener second_inner_listener; 3049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!second_matcher_.MatchAndExplain(a_pair.second, 3050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch &second_inner_listener)) { 3051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose second field does not match"; 3052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(second_inner_listener.str(), listener->stream()); 3053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 3054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(), 3056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener); 3057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 3058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void ExplainSuccess(const internal::string& first_explanation, 3062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string& second_explanation, 3063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 3064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose both fields match"; 3065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (first_explanation != "") { 3066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ", where the first field is a value " << first_explanation; 3067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (second_explanation != "") { 3069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ", "; 3070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (first_explanation != "") { 3071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "and "; 3072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 3073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "where "; 3074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "the second field is a value " << second_explanation; 3076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const FirstType&> first_matcher_; 3080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const SecondType&> second_matcher_; 3081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PairMatcherImpl); 3083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements polymorphic Pair(first_matcher, second_matcher). 3086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename FirstMatcher, typename SecondMatcher> 3087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PairMatcher { 3088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher) 3090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : first_matcher_(first_matcher), second_matcher_(second_matcher) {} 3091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename PairType> 3093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<PairType> () const { 3094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher( 3095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new PairMatcherImpl<PairType>( 3096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch first_matcher_, second_matcher_)); 3097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const FirstMatcher first_matcher_; 3101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const SecondMatcher second_matcher_; 3102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(PairMatcher); 3104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements ElementsAre() and ElementsAreArray(). 3107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 3108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ElementsAreMatcherImpl : public MatcherInterface<Container> { 3109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; 3111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView<RawContainer> View; 3112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::type StlContainer; 3113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::const_reference StlContainerReference; 3114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename StlContainer::value_type Element; 3115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs the matcher from a sequence of element values or 3117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // element matchers. 3118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InputIter> 3119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAreMatcherImpl(InputIter first, InputIter last) { 3120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch while (first != last) { 3121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_.push_back(MatcherCast<const Element&>(*first++)); 3122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher does. 3126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 3127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (count() == 0) { 3128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is empty"; 3129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else if (count() == 1) { 3130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has 1 element that "; 3131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_[0].DescribeTo(os); 3132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 3133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "has " << Elements(count()) << " where\n"; 3134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i != count(); ++i) { 3135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "element #" << i << " "; 3136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_[i].DescribeTo(os); 3137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (i + 1 < count()) { 3138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ",\n"; 3139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what the negation of this matcher does. 3145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 3146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (count() == 0) { 3147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "isn't empty"; 3148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return; 3149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't have " << Elements(count()) << ", or\n"; 3152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i != count(); ++i) { 3153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "element #" << i << " "; 3154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_[i].DescribeNegationTo(os); 3155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (i + 1 < count()) { 3156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << ", or\n"; 3157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Container container, 3162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 3163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // To work with stream-like "containers", we must only walk 3164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // through the elements in one pass. 3165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool listener_interested = listener->IsInterested(); 3167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explanations[i] is the explanation of the element at index i. 3169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<internal::string> explanations(count()); 3170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StlContainerReference stl_container = View::ConstReference(container); 3171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename StlContainer::const_iterator it = stl_container.begin(); 3172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t exam_pos = 0; 3173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool mismatch_found = false; // Have we found a mismatched element yet? 3174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Go through the elements and matchers in pairs, until we reach 3176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the end of either the elements or the matchers, or until we find a 3177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // mismatch. 3178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) { 3179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool match; // Does the current element match the current matcher? 3180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener_interested) { 3181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener s; 3182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch match = matchers_[exam_pos].MatchAndExplain(*it, &s); 3183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explanations[exam_pos] = s.str(); 3184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 3185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch match = matchers_[exam_pos].Matches(*it); 3186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!match) { 3189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mismatch_found = true; 3190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch break; 3191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If mismatch_found is true, 'exam_pos' is the index of the mismatch. 3194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Find how many elements the actual container has. We avoid 3196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // calling size() s.t. this code works for stream-like "containers" 3197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // that don't define size(). 3198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t actual_count = exam_pos; 3199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (; it != stl_container.end(); ++it) { 3200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ++actual_count; 3201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual_count != count()) { 3204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The element count doesn't match. If the container is empty, 3205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // there's no need to explain anything as Google Mock already 3206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // prints the empty container. Otherwise we just need to show 3207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // how many elements there actually are. 3208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener_interested && (actual_count != 0)) { 3209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which has " << Elements(actual_count); 3210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 3212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (mismatch_found) { 3215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The element count matches, but the exam_pos-th element doesn't match. 3216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener_interested) { 3217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose element #" << exam_pos << " doesn't match"; 3218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintIfNotEmpty(explanations[exam_pos], listener->stream()); 3219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 3221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Every element matches its expectation. We need to explain why 3224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // (the obvious ones can be skipped). 3225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener_interested) { 3226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool reason_printed = false; 3227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i != count(); ++i) { 3228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string& s = explanations[i]; 3229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!s.empty()) { 3230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (reason_printed) { 3231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << ",\nand "; 3232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "whose element #" << i << " matches, " << s; 3234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch reason_printed = true; 3235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 3239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Message Elements(size_t count) { 3243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Message() << count << (count == 1 ? " element" : " elements"); 3244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t count() const { return matchers_.size(); } 3247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<Matcher<const Element&> > matchers_; 3249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl); 3251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Connectivity matrix of (elements X matchers), in element-major order. 3254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Initially, there are no edges. 3255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Use NextGraph() to iterate over all possible edge configurations. 3256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Use Randomize() to generate a random edge configuration. 3257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ MatchMatrix { 3258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix(size_t num_elements, size_t num_matchers) 3260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : num_elements_(num_elements), 3261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch num_matchers_(num_matchers), 3262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matched_(num_elements_* num_matchers_, 0) { 3263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t LhsSize() const { return num_elements_; } 3266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t RhsSize() const { return num_matchers_; } 3267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool HasEdge(size_t ilhs, size_t irhs) const { 3268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return matched_[SpaceIndex(ilhs, irhs)] == 1; 3269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void SetEdge(size_t ilhs, size_t irhs, bool b) { 3271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0; 3272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number, 3275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // adds 1 to that number; returns false if incrementing the graph left it 3276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // empty. 3277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool NextGraph(); 3278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void Randomize(); 3280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string DebugString() const; 3282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t SpaceIndex(size_t ilhs, size_t irhs) const { 3285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ilhs * num_matchers_ + irhs; 3286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t num_elements_; 3289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t num_matchers_; 3290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Each element is a char interpreted as bool. They are stored as a 3292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // flattened array in lhs-major order, use 'SpaceIndex()' to translate 3293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // a (ilhs, irhs) matrix coordinate into an offset. 3294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<char> matched_; 3295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef ::std::pair<size_t, size_t> ElementMatcherPair; 3298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef ::std::vector<ElementMatcherPair> ElementMatcherPairs; 3299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a maximum bipartite matching for the specified graph 'g'. 3301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The matching is represented as a vector of {element, matcher} pairs. 3302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ ElementMatcherPairs 3303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochFindMaxBipartiteMatching(const MatchMatrix& g); 3304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ bool FindPairing(const MatchMatrix& matrix, 3306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener); 3307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Untyped base class for implementing UnorderedElementsAre. By 3309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// putting logic that's not specific to the element type here, we 3310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// reduce binary bloat and increase compilation speed. 3311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GTEST_API_ UnorderedElementsAreMatcherImplBase { 3312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 3313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A vector of matcher describers, one for each element matcher. 3314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Does not own the describers (and thus can be used only when the 3315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // element matchers are alive). 3316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec; 3317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes this UnorderedElementsAre matcher. 3319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeToImpl(::std::ostream* os) const; 3320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes the negation of this UnorderedElementsAre matcher. 3322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationToImpl(::std::ostream* os) const; 3323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool VerifyAllElementsAndMatchersAreMatched( 3325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ::std::vector<string>& element_printouts, 3326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const MatchMatrix& matrix, 3327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const; 3328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherDescriberVec& matcher_describers() { 3330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return matcher_describers_; 3331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static Message Elements(size_t n) { 3334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Message() << n << " element" << (n == 1 ? "" : "s"); 3335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherDescriberVec matcher_describers_; 3339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImplBase); 3341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements unordered ElementsAre and unordered ElementsAreArray. 3344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 3345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass UnorderedElementsAreMatcherImpl 3346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public MatcherInterface<Container>, 3347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public UnorderedElementsAreMatcherImplBase { 3348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; 3350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef internal::StlContainerView<RawContainer> View; 3351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::type StlContainer; 3352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::const_reference StlContainerReference; 3353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename StlContainer::const_iterator StlContainerConstIterator; 3354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename StlContainer::value_type Element; 3355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Constructs the matcher from a sequence of element values or 3357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // element matchers. 3358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InputIter> 3359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UnorderedElementsAreMatcherImpl(InputIter first, InputIter last) { 3360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (; first != last; ++first) { 3361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_.push_back(MatcherCast<const Element&>(*first)); 3362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher_describers().push_back(matchers_.back().GetDescriber()); 3363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what this matcher does. 3367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 3368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os); 3369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Describes what the negation of this matcher does. 3372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeNegationTo(::std::ostream* os) const { 3373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os); 3374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(Container container, 3377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 3378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StlContainerReference stl_container = View::ConstReference(container); 3379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<string> element_printouts; 3380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix matrix = AnalyzeElements(stl_container.begin(), 3381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stl_container.end(), 3382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch &element_printouts, 3383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener); 3384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const size_t actual_count = matrix.LhsSize(); 3386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual_count == 0 && matchers_.empty()) { 3387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 3388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual_count != matchers_.size()) { 3390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The element count doesn't match. If the container is empty, 3391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // there's no need to explain anything as Google Mock already 3392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // prints the empty container. Otherwise we just need to show 3393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // how many elements there actually are. 3394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (actual_count != 0 && listener->IsInterested()) { 3395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which has " << Elements(actual_count); 3396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 3398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return VerifyAllElementsAndMatchersAreMatched(element_printouts, 3401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matrix, listener) && 3402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FindPairing(matrix, listener); 3403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::vector<Matcher<const Element&> > MatcherVec; 3407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename ElementIter> 3409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last, 3410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<string>* element_printouts, 3411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 3412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch element_printouts->clear(); 3413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<char> did_match; 3414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t num_elements = 0; 3415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (; elem_first != elem_last; ++num_elements, ++elem_first) { 3416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener->IsInterested()) { 3417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch element_printouts->push_back(PrintToString(*elem_first)); 3418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) { 3420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch did_match.push_back(Matches(matchers_[irhs])(*elem_first)); 3421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix matrix(num_elements, matchers_.size()); 3425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<char>::const_iterator did_match_iter = did_match.begin(); 3426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) { 3427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) { 3428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0); 3429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return matrix; 3432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherVec matchers_; 3435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImpl); 3437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Functor for use in TransformTuple. 3440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Performs MatcherCast<Target> on an input argument of any type. 3441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Target> 3442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct CastAndAppendTransform { 3443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Arg> 3444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Target> operator()(const Arg& a) const { 3445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatcherCast<Target>(a); 3446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements UnorderedElementsAre. 3450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename MatcherTuple> 3451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass UnorderedElementsAreMatcher { 3452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit UnorderedElementsAreMatcher(const MatcherTuple& args) 3454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matchers_(args) {} 3455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 3457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 3458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; 3459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename internal::StlContainerView<RawContainer>::type View; 3460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::value_type Element; 3461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::vector<Matcher<const Element&> > MatcherVec; 3462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherVec matchers; 3463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers.reserve(::testing::tuple_size<MatcherTuple>::value); 3464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_, 3465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::back_inserter(matchers)); 3466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>( 3467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers.begin(), matchers.end())); 3468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const MatcherTuple matchers_; 3472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcher); 3473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements ElementsAre. 3476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename MatcherTuple> 3477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ElementsAreMatcher { 3478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {} 3480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 3482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 3483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer; 3484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename internal::StlContainerView<RawContainer>::type View; 3485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename View::value_type Element; 3486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::std::vector<Matcher<const Element&> > MatcherVec; 3487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherVec matchers; 3488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers.reserve(::testing::tuple_size<MatcherTuple>::value); 3489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_, 3490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::back_inserter(matchers)); 3491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new ElementsAreMatcherImpl<Container>( 3492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers.begin(), matchers.end())); 3493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const MatcherTuple matchers_; 3497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher); 3498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements UnorderedElementsAreArray(). 3501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass UnorderedElementsAreArrayMatcher { 3503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UnorderedElementsAreArrayMatcher() {} 3505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Iter> 3507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UnorderedElementsAreArrayMatcher(Iter first, Iter last) 3508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : matchers_(first, last) {} 3509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 3511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 3512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher( 3513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch new UnorderedElementsAreMatcherImpl<Container>(matchers_.begin(), 3514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_.end())); 3515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<T> matchers_; 3519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreArrayMatcher); 3521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implements ElementsAreArray(). 3524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ElementsAreArrayMatcher { 3526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Iter> 3528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {} 3529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename Container> 3531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<Container>() const { 3532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new ElementsAreMatcherImpl<Container>( 3533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers_.begin(), matchers_.end())); 3534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ::std::vector<T> matchers_; 3538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(ElementsAreArrayMatcher); 3540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second 3543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm, 3544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second) is a polymorphic matcher that matches a value x iff tm 3545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches tuple (x, second). Useful for implementing 3546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedPointwise() in terms of UnorderedElementsAreArray(). 3547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// BoundSecondMatcher is copyable and assignable, as we need to put 3549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// instances of this class in a vector when implementing 3550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedPointwise(). 3551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Tuple2Matcher, typename Second> 3552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BoundSecondMatcher { 3553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second) 3555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : tuple2_matcher_(tm), second_value_(second) {} 3556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 3558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator Matcher<T>() const { 3559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_)); 3560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We have to define this for UnorderedPointwise() to compile in 3563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // C++98 mode, as it puts BoundSecondMatcher instances in a vector, 3564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which requires the elements to be assignable in C++98. The 3565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // compiler cannot generate the operator= for us, as Tuple2Matcher 3566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // and Second may not be assignable. 3567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 3568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // However, this should never be called, so the implementation just 3569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // need to assert. 3570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void operator=(const BoundSecondMatcher& /*rhs*/) { 3571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned."; 3572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 3576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class Impl : public MatcherInterface<T> { 3577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ::testing::tuple<T, Second> ArgTuple; 3579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Impl(const Tuple2Matcher& tm, const Second& second) 3581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)), 3582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch second_value_(second) {} 3583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 3585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "and "; 3586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UniversalPrint(second_value_, os); 3587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << " "; 3588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mono_tuple2_matcher_.DescribeTo(os); 3589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(T x, MatchResultListener* listener) const { 3592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_), 3593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener); 3594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ArgTuple&> mono_tuple2_matcher_; 3598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Second second_value_; 3599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(Impl); 3601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 3602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Tuple2Matcher tuple2_matcher_; 3604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Second second_value_; 3605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Given a 2-tuple matcher tm and a value second, 3608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherBindSecond(tm, second) returns a matcher that matches a 3609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// value x iff tm matches tuple (x, second). Useful for implementing 3610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedPointwise() in terms of UnorderedElementsAreArray(). 3611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Tuple2Matcher, typename Second> 3612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochBoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond( 3613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Tuple2Matcher& tm, const Second& second) { 3614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second); 3615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the description for a matcher defined using the MATCHER*() 3618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// macro where the user-supplied description string is "", if 3619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'negation' is false; otherwise returns the description of the 3620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// negation of the matcher. 'param_values' contains a list of strings 3621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that are the print-out of the matcher's parameters. 3622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ string FormatMatcherDescription(bool negation, 3623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* matcher_name, 3624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Strings& param_values); 3625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 3627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ElementsAreArray(first, last) 3629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ElementsAreArray(pointer, count) 3630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ElementsAreArray(array) 3631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ElementsAreArray(container) 3632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ElementsAreArray({ e1, e2, ..., en }) 3633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The ElementsAreArray() functions are like ElementsAre(...), except 3635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that they are given a homogeneous sequence rather than taking each 3636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// element as a function argument. The sequence can be specified as an 3637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// array, a pointer and count, a vector, an initializer list, or an 3638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// STL iterator range. In each of these cases, the underlying sequence 3639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can be either a sequence of values or a sequence of matchers. 3640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// All forms of ElementsAreArray() make a copy of the input matcher sequence. 3642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Iter> 3644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::ElementsAreArrayMatcher< 3645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::std::iterator_traits<Iter>::value_type> 3646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochElementsAreArray(Iter first, Iter last) { 3647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename ::std::iterator_traits<Iter>::value_type T; 3648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::ElementsAreArrayMatcher<T>(first, last); 3649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::ElementsAreArrayMatcher<T> ElementsAreArray( 3653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const T* pointer, size_t count) { 3654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ElementsAreArray(pointer, pointer + count); 3655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, size_t N> 3658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::ElementsAreArrayMatcher<T> ElementsAreArray( 3659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const T (&array)[N]) { 3660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ElementsAreArray(array, N); 3661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 3664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::ElementsAreArrayMatcher<typename Container::value_type> 3665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochElementsAreArray(const Container& container) { 3666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ElementsAreArray(container.begin(), container.end()); 3667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 3670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::ElementsAreArrayMatcher<T> 3672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochElementsAreArray(::std::initializer_list<T> xs) { 3673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ElementsAreArray(xs.begin(), xs.end()); 3674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 3676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedElementsAreArray(first, last) 3678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedElementsAreArray(pointer, count) 3679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedElementsAreArray(array) 3680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedElementsAreArray(container) 3681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedElementsAreArray({ e1, e2, ..., en }) 3682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The UnorderedElementsAreArray() functions are like 3684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ElementsAreArray(...), but allow matching the elements in any order. 3685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Iter> 3686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher< 3687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename ::std::iterator_traits<Iter>::value_type> 3688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedElementsAreArray(Iter first, Iter last) { 3689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename ::std::iterator_traits<Iter>::value_type T; 3690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::UnorderedElementsAreArrayMatcher<T>(first, last); 3691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher<T> 3695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedElementsAreArray(const T* pointer, size_t count) { 3696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreArray(pointer, pointer + count); 3697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, size_t N> 3700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher<T> 3701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedElementsAreArray(const T (&array)[N]) { 3702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreArray(array, N); 3703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 3706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher< 3707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename Container::value_type> 3708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedElementsAreArray(const Container& container) { 3709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreArray(container.begin(), container.end()); 3710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 3713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher<T> 3715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedElementsAreArray(::std::initializer_list<T> xs) { 3716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreArray(xs.begin(), xs.end()); 3717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 3719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// _ is a matcher that matches anything of any type. 3721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This definition is fine as: 3723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 1. The C++ standard permits using the name _ in a namespace that 3725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is not the global namespace or ::std. 3726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 2. The AnythingMatcher class has no data member or constructor, 3727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// so it's OK to create global variables of this type. 3728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3. c-style has approved of using _ in this case. 3729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst internal::AnythingMatcher _ = {}; 3730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any value of the given type T. 3731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline Matcher<T> A() { return MakeMatcher(new internal::AnyMatcherImpl<T>()); } 3733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any value of the given type T. 3735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline Matcher<T> An() { return A<T>(); } 3737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches anything equal to x. 3739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Note: if the parameter of Eq() were declared as const T&, Eq("foo") 3740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// wouldn't compile. 3741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); } 3743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Constructs a Matcher<T> from a 'value' of type T. The constructed 3745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher matches any value that's equal to 'value'. 3746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMatcher<T>::Matcher(T value) { *this = Eq(value); } 3748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a monomorphic matcher that matches anything with type Lhs 3750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and equal to rhs. A user may need to use this instead of Eq(...) 3751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// in order to resolve an overloading ambiguity. 3752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x)) 3754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// or Matcher<T>(x), but more readable than the latter. 3755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 3756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We could define similar monomorphic matchers for other comparison 3757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do 3758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// it yet as those are used much less than Eq() in practice. A user 3759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can always write Matcher<T>(Lt(5)) to be explicit about the type, 3760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// for example. 3761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Lhs, typename Rhs> 3762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); } 3763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches anything >= x. 3765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 3766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::GeMatcher<Rhs> Ge(Rhs x) { 3767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::GeMatcher<Rhs>(x); 3768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches anything > x. 3771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 3772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::GtMatcher<Rhs> Gt(Rhs x) { 3773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::GtMatcher<Rhs>(x); 3774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches anything <= x. 3777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 3778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::LeMatcher<Rhs> Le(Rhs x) { 3779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::LeMatcher<Rhs>(x); 3780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches anything < x. 3783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 3784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::LtMatcher<Rhs> Lt(Rhs x) { 3785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::LtMatcher<Rhs>(x); 3786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches anything != x. 3789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Rhs> 3790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::NeMatcher<Rhs> Ne(Rhs x) { 3791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::NeMatcher<Rhs>(x); 3792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches any NULL pointer. 3795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::IsNullMatcher > IsNull() { 3796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::IsNullMatcher()); 3797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches any non-NULL pointer. 3800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This is convenient as Not(NULL) doesn't compile (the compiler 3801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// thinks that that expression is comparing a pointer with an integer). 3802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::NotNullMatcher > NotNull() { 3803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::NotNullMatcher()); 3804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches any argument that 3807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// references variable x. 3808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::RefMatcher<T&> Ref(T& x) { // NOLINT 3810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::RefMatcher<T&>(x); 3811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any double argument approximately 3814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// equal to rhs, where two NANs are considered unequal. 3815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<double> DoubleEq(double rhs) { 3816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<double>(rhs, false); 3817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any double argument approximately 3820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// equal to rhs, including NaN values when rhs is NaN. 3821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) { 3822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<double>(rhs, true); 3823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any double argument approximately equal to 3826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// rhs, up to the specified max absolute error bound, where two NANs are 3827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// considered unequal. The max absolute error bound must be non-negative. 3828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<double> DoubleNear( 3829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double rhs, double max_abs_error) { 3830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error); 3831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any double argument approximately equal to 3834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// rhs, up to the specified max absolute error bound, including NaN values when 3835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// rhs is NaN. The max absolute error bound must be non-negative. 3836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear( 3837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double rhs, double max_abs_error) { 3838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error); 3839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any float argument approximately 3842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// equal to rhs, where two NANs are considered unequal. 3843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<float> FloatEq(float rhs) { 3844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<float>(rhs, false); 3845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any float argument approximately 3848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// equal to rhs, including NaN values when rhs is NaN. 3849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) { 3850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<float>(rhs, true); 3851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any float argument approximately equal to 3854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// rhs, up to the specified max absolute error bound, where two NANs are 3855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// considered unequal. The max absolute error bound must be non-negative. 3856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<float> FloatNear( 3857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch float rhs, float max_abs_error) { 3858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error); 3859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any float argument approximately equal to 3862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// rhs, up to the specified max absolute error bound, including NaN values when 3863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// rhs is NaN. The max absolute error bound must be non-negative. 3864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::FloatingEqMatcher<float> NanSensitiveFloatNear( 3865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch float rhs, float max_abs_error) { 3866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error); 3867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches a pointer (raw or smart) that points 3870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// to a value that matches inner_matcher. 3871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename InnerMatcher> 3872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::PointeeMatcher<InnerMatcher> Pointee( 3873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const InnerMatcher& inner_matcher) { 3874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::PointeeMatcher<InnerMatcher>(inner_matcher); 3875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches a pointer or reference that matches 3878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// inner_matcher when dynamic_cast<To> is applied. 3879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The result of dynamic_cast<To> is forwarded to the inner matcher. 3880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If To is a pointer and the cast fails, the inner matcher will receive NULL. 3881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If To is a reference and the cast fails, this matcher returns false 3882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// immediately. 3883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename To> 3884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> > 3885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochWhenDynamicCastTo(const Matcher<To>& inner_matcher) { 3886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher( 3887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::WhenDynamicCastToMatcher<To>(inner_matcher)); 3888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches an object whose given field matches 3891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'matcher'. For example, 3892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Field(&Foo::number, Ge(5)) 3893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches a Foo object x iff x.number >= 5. 3894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Class, typename FieldType, typename FieldMatcher> 3895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher< 3896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::FieldMatcher<Class, FieldType> > Field( 3897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FieldType Class::*field, const FieldMatcher& matcher) { 3898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher( 3899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::FieldMatcher<Class, FieldType>( 3900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch field, MatcherCast<const FieldType&>(matcher))); 3901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The call to MatcherCast() is required for supporting inner 3902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matchers of compatible types. For example, it allows 3903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Field(&Foo::bar, m) 3904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to compile where bar is an int32 and m is a matcher for int64. 3905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches an object whose given property 3908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches 'matcher'. For example, 3909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Property(&Foo::str, StartsWith("hi")) 3910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches a Foo object x iff x.str() starts with "hi". 3911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Class, typename PropertyType, typename PropertyMatcher> 3912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher< 3913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::PropertyMatcher<Class, PropertyType> > Property( 3914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PropertyType (Class::*property)() const, const PropertyMatcher& matcher) { 3915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher( 3916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::PropertyMatcher<Class, PropertyType>( 3917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch property, 3918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher))); 3919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The call to MatcherCast() is required for supporting inner 3920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matchers of compatible types. For example, it allows 3921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Property(&Foo::bar, m) 3922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to compile where bar() returns an int32 and m is a matcher for int64. 3923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches an object iff the result of applying 3926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a callable to x matches 'matcher'. 3927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For example, 3928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ResultOf(f, StartsWith("hi")) 3929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches a Foo object x iff f(x) starts with "hi". 3930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// callable parameter can be a function, function pointer, or a functor. 3931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Callable has to satisfy the following conditions: 3932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * It is required to keep no state affecting the results of 3933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the calls on it and make no assumptions about how many calls 3934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// will be made. Any state it keeps must be protected from the 3935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// concurrent access. 3936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// * If it is a function object, it has to define type result_type. 3937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We recommend deriving your functor classes from std::unary_function. 3938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Callable, typename ResultOfMatcher> 3939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinternal::ResultOfMatcher<Callable> ResultOf( 3940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Callable callable, const ResultOfMatcher& matcher) { 3941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::ResultOfMatcher<Callable>( 3942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch callable, 3943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherCast<typename internal::CallableTraits<Callable>::ResultType>( 3944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher)); 3945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The call to MatcherCast() is required for supporting inner 3946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matchers of compatible types. For example, it allows 3947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // ResultOf(Function, m) 3948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to compile where Function() returns an int32 and m is a matcher for int64. 3949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// String matchers. 3952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string equal to str. 3954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > 3955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrEq(const internal::string& str) { 3956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>( 3957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, true, true)); 3958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string not equal to str. 3961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > 3962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrNe(const internal::string& str) { 3963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>( 3964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, false, true)); 3965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string equal to str, ignoring case. 3968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > 3969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrCaseEq(const internal::string& str) { 3970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>( 3971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, true, false)); 3972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string not equal to str, ignoring case. 3975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> > 3976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrCaseNe(const internal::string& str) { 3977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>( 3978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, false, false)); 3979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any string, std::string, or C string 3982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that contains the given substring. 3983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> > 3984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch HasSubstr(const internal::string& substring) { 3985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>( 3986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch substring)); 3987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string that starts with 'prefix' (case-sensitive). 3990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> > 3991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StartsWith(const internal::string& prefix) { 3992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>( 3993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch prefix)); 3994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string that ends with 'suffix' (case-sensitive). 3997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> > 3998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EndsWith(const internal::string& suffix) { 3999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>( 4000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch suffix)); 4001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string that fully matches regular expression 'regex'. 4004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The matcher takes ownership of 'regex'. 4005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( 4006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::RE* regex) { 4007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true)); 4008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( 4010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string& regex) { 4011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MatchesRegex(new internal::RE(regex)); 4012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string that contains regular expression 'regex'. 4015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The matcher takes ownership of 'regex'. 4016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( 4017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::RE* regex) { 4018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false)); 4019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( 4021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const internal::string& regex) { 4022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ContainsRegex(new internal::RE(regex)); 4023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING 4026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Wide string matchers. 4027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string equal to str. 4029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> > 4030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrEq(const internal::wstring& str) { 4031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>( 4032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, true, true)); 4033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string not equal to str. 4036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> > 4037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrNe(const internal::wstring& str) { 4038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>( 4039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, false, true)); 4040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string equal to str, ignoring case. 4043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> > 4044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrCaseEq(const internal::wstring& str) { 4045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>( 4046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, true, false)); 4047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string not equal to str, ignoring case. 4050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> > 4051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StrCaseNe(const internal::wstring& str) { 4052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>( 4053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str, false, false)); 4054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any wstring, std::wstring, or C wide string 4057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// that contains the given substring. 4058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> > 4059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch HasSubstr(const internal::wstring& substring) { 4060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::wstring>( 4061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch substring)); 4062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string that starts with 'prefix' (case-sensitive). 4065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> > 4066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StartsWith(const internal::wstring& prefix) { 4067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::wstring>( 4068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch prefix)); 4069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches a string that ends with 'suffix' (case-sensitive). 4072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> > 4073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EndsWith(const internal::wstring& suffix) { 4074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::wstring>( 4075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch suffix)); 4076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING 4079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches a 2-tuple where the 4081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// first field == the second field. 4082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); } 4083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches a 2-tuple where the 4085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// first field >= the second field. 4086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); } 4087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches a 2-tuple where the 4089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// first field > the second field. 4090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); } 4091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches a 2-tuple where the 4093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// first field <= the second field. 4094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::Le2Matcher Le() { return internal::Le2Matcher(); } 4095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches a 2-tuple where the 4097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// first field < the second field. 4098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); } 4099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a polymorphic matcher that matches a 2-tuple where the 4101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// first field != the second field. 4102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); } 4103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Creates a matcher that matches any value of type T that m doesn't 4105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// match. 4106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename InnerMatcher> 4107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) { 4108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::NotMatcher<InnerMatcher>(m); 4109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a matcher that matches anything that satisfies the given 4112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// predicate. The predicate can be any unary function or functor 4113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// whose return type can be implicitly converted to bool. 4114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Predicate> 4115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::TrulyMatcher<Predicate> > 4116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTruly(Predicate pred) { 4117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred)); 4118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a matcher that matches the container size. The container must 4121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// support both size() and size_type which all STL-like containers provide. 4122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Note that the parameter 'size' can be a value of type size_type as well as 4123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher. For instance: 4124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(container, SizeIs(2)); // Checks container has 2 elements. 4125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(container, SizeIs(Le(2)); // Checks container has at most 2. 4126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename SizeMatcher> 4127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::SizeIsMatcher<SizeMatcher> 4128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochSizeIs(const SizeMatcher& size_matcher) { 4129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::SizeIsMatcher<SizeMatcher>(size_matcher); 4130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a matcher that matches the distance between the container's begin() 4133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// iterator and its end() iterator, i.e. the size of the container. This matcher 4134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can be used instead of SizeIs with containers such as std::forward_list which 4135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// do not implement size(). The container must provide const_iterator (with 4136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// valid iterator_traits), begin() and end(). 4137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename DistanceMatcher> 4138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::BeginEndDistanceIsMatcher<DistanceMatcher> 4139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochBeginEndDistanceIs(const DistanceMatcher& distance_matcher) { 4140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher); 4141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a matcher that matches an equal container. 4144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This matcher behaves like Eq(), but in the event of mismatch lists the 4145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// values that are included in one container but not the other. (Duplicate 4146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// values and order differences are not explained.) 4147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Container> 4148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline PolymorphicMatcher<internal::ContainerEqMatcher< // NOLINT 4149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_CONST_(Container)> > 4150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ContainerEq(const Container& rhs) { 4151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This following line is for working around a bug in MSVC 8.0, 4152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which causes Container to be a const type sometimes. 4153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_CONST_(Container) RawContainer; 4154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher( 4155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::ContainerEqMatcher<RawContainer>(rhs)); 4156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a matcher that matches a container that, when sorted using 4159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the given comparator, matches container_matcher. 4160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Comparator, typename ContainerMatcher> 4161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::WhenSortedByMatcher<Comparator, ContainerMatcher> 4162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochWhenSortedBy(const Comparator& comparator, 4163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ContainerMatcher& container_matcher) { 4164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>( 4165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch comparator, container_matcher); 4166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a matcher that matches a container that, when sorted using 4169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the < operator, matches container_matcher. 4170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename ContainerMatcher> 4171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher> 4172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochWhenSorted(const ContainerMatcher& container_matcher) { 4173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return 4174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>( 4175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::LessComparator(), container_matcher); 4176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches an STL-style container or a native array that contains the 4179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// same number of elements as in rhs, where its i-th element and rhs's 4180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// i-th element (as a pair) satisfy the given pair matcher, for all i. 4181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// TupleMatcher must be able to be safely cast to Matcher<tuple<const 4182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T1&, const T2&> >, where T1 and T2 are the types of elements in the 4183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// LHS container and the RHS container respectively. 4184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename TupleMatcher, typename Container> 4185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::PointwiseMatcher<TupleMatcher, 4186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_REMOVE_CONST_(Container)> 4187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochPointwise(const TupleMatcher& tuple_matcher, const Container& rhs) { 4188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This following line is for working around a bug in MSVC 8.0, 4189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which causes Container to be a const type sometimes (e.g. when 4190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // rhs is a const int[]).. 4191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_CONST_(Container) RawContainer; 4192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::PointwiseMatcher<TupleMatcher, RawContainer>( 4193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch tuple_matcher, rhs); 4194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 4197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Supports the Pointwise(m, {a, b, c}) syntax. 4199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename TupleMatcher, typename T> 4200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise( 4201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) { 4202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return Pointwise(tuple_matcher, std::vector<T>(rhs)); 4203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_INITIALIZER_LIST_ 4206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// UnorderedPointwise(pair_matcher, rhs) matches an STL-style 4208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// container or a native array that contains the same number of 4209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// elements as in rhs, where in some permutation of the container, its 4210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// i-th element and rhs's i-th element (as a pair) satisfy the given 4211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// pair matcher, for all i. Tuple2Matcher must be able to be safely 4212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// cast to Matcher<tuple<const T1&, const T2&> >, where T1 and T2 are 4213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the types of elements in the LHS container and the RHS container 4214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// respectively. 4215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This is like Pointwise(pair_matcher, rhs), except that the element 4217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// order doesn't matter. 4218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Tuple2Matcher, typename RhsContainer> 4219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher< 4220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename internal::BoundSecondMatcher< 4221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Tuple2Matcher, typename internal::StlContainerView<GTEST_REMOVE_CONST_( 4222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RhsContainer)>::type::value_type> > 4223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedPointwise(const Tuple2Matcher& tuple2_matcher, 4224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RhsContainer& rhs_container) { 4225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This following line is for working around a bug in MSVC 8.0, 4226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which causes RhsContainer to be a const type sometimes (e.g. when 4227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // rhs_container is a const int[]). 4228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer; 4229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // RhsView allows the same code to handle RhsContainer being a 4231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // STL-style container and it being a native C-style array. 4232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename internal::StlContainerView<RawRhsContainer> RhsView; 4233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RhsView::type RhsStlContainer; 4234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename RhsStlContainer::value_type Second; 4235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RhsStlContainer& rhs_stl_container = 4236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RhsView::ConstReference(rhs_container); 4237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Create a matcher for each element in rhs_container. 4239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers; 4240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin(); 4241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch it != rhs_stl_container.end(); ++it) { 4242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matchers.push_back( 4243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::MatcherBindSecond(tuple2_matcher, *it)); 4244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Delegate the work to UnorderedElementsAreArray(). 4247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedElementsAreArray(matchers); 4248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 4251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Supports the UnorderedPointwise(m, {a, b, c}) syntax. 4253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Tuple2Matcher, typename T> 4254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::UnorderedElementsAreArrayMatcher< 4255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename internal::BoundSecondMatcher<Tuple2Matcher, T> > 4256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUnorderedPointwise(const Tuple2Matcher& tuple2_matcher, 4257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::initializer_list<T> rhs) { 4258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs)); 4259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_INITIALIZER_LIST_ 4262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches an STL-style container or a native array that contains at 4264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// least one element matching the given value or matcher. 4265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Examples: 4267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ::std::set<int> page_ids; 4268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_ids.insert(3); 4269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_ids.insert(1); 4270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Contains(1)); 4271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Contains(Gt(2))); 4272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Not(Contains(4))); 4273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ::std::map<int, size_t> page_lengths; 4275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_lengths[1] = 100; 4276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_lengths, 4277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Contains(::std::pair<const int, size_t>(1, 100))); 4278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// const char* user_ids[] = { "joe", "mike", "tom" }; 4280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom")))); 4281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 4282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::ContainsMatcher<M> Contains(M matcher) { 4283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::ContainsMatcher<M>(matcher); 4284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches an STL-style container or a native array that contains only 4287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// elements matching the given value or matcher. 4288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only 4290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the messages are different. 4291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Examples: 4293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ::std::set<int> page_ids; 4294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// // Each(m) matches an empty container, regardless of what m is. 4295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Each(Eq(1))); 4296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Each(Eq(77))); 4297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_ids.insert(3); 4299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Each(Gt(0))); 4300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Not(Each(Gt(4)))); 4301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_ids.insert(1); 4302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_ids, Not(Each(Lt(2)))); 4303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ::std::map<int, size_t> page_lengths; 4305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_lengths[1] = 100; 4306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_lengths[2] = 200; 4307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// page_lengths[3] = 300; 4308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100)))); 4309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(page_lengths, Each(Key(Le(3)))); 4310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// const char* user_ids[] = { "joe", "mike", "tom" }; 4312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom"))))); 4313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 4314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::EachMatcher<M> Each(M matcher) { 4315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::EachMatcher<M>(matcher); 4316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Key(inner_matcher) matches an std::pair whose 'first' field matches 4319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an 4320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// std::map that contains at least one element whose key is >= 5. 4321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 4322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::KeyMatcher<M> Key(M inner_matcher) { 4323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::KeyMatcher<M>(inner_matcher); 4324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field 4327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches first_matcher and whose 'second' field matches second_matcher. For 4328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used 4329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// to match a std::map<int, string> that contains exactly one element whose key 4330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is >= 5 and whose value equals "foo". 4331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename FirstMatcher, typename SecondMatcher> 4332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::PairMatcher<FirstMatcher, SecondMatcher> 4333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochPair(FirstMatcher first_matcher, SecondMatcher second_matcher) { 4334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::PairMatcher<FirstMatcher, SecondMatcher>( 4335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch first_matcher, second_matcher); 4336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns a predicate that is satisfied by anything that matches the 4339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// given matcher. 4340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename M> 4341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::MatcherAsPredicate<M> Matches(M matcher) { 4342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::MatcherAsPredicate<M>(matcher); 4343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns true iff the value matches the matcher. 4346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename M> 4347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool Value(const T& value, M matcher) { 4348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return testing::Matches(matcher)(value); 4349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches the value against the given matcher and explains the match 4352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// result to listener. 4353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T, typename M> 4354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline bool ExplainMatchResult( 4355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch M matcher, const T& value, MatchResultListener* listener) { 4356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener); 4357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 4360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Define variadic matcher versions. They are overloaded in 4361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// gmock-generated-matchers.h for the cases supported by pre C++11 compilers. 4362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename... Args> 4363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::AllOfMatcher<Args...> AllOf(const Args&... matchers) { 4364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::AllOfMatcher<Args...>(matchers...); 4365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename... Args> 4368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline internal::AnyOfMatcher<Args...> AnyOf(const Args&... matchers) { 4369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return internal::AnyOfMatcher<Args...>(matchers...); 4370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 4373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// AllArgs(m) is a synonym of m. This is useful in 4375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq())); 4377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// which is easier to read than 4379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 4380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// EXPECT_CALL(foo, Bar(_, _)).With(Eq()); 4381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename InnerMatcher> 4382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochinline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; } 4383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// These macros allow using matchers to check values in Google Test 4385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher) 4386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// succeed iff the value matches the matcher. If the assertion fails, 4387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the value and the description of the matcher will be printed. 4388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\ 4389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) 4390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\ 4391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) 4392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace testing 4394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Include any custom callback matchers added by the local installation. 4396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// We must include this header at the end to make sure it can use the 4397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// declarations from this file. 4398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gmock/internal/custom/gmock-matchers.h" 4399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 4400