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 tests some commonly used argument matchers. 35f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 36f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gmock/gmock-matchers.h" 37f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gmock/gmock-more-matchers.h" 38f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 39f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <string.h> 40f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <time.h> 41f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <deque> 42f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <functional> 43f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <iostream> 44f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <iterator> 45f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <limits> 46f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <list> 47f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <map> 48f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <set> 49f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <sstream> 50f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <string> 51f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <utility> 52f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <vector> 53f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gmock/gmock.h" 54f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/gtest.h" 55f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "gtest/gtest-spi.h" 56f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 57f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_FORWARD_LIST_ 58f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch# include <forward_list> // NOLINT 59f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 60f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 61f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace testing { 62f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 63f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 64f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochGTEST_API_ string JoinAsTuple(const Strings& fields); 65f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 66f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 67f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace gmock_matchers_test { 68f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 69f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::greater; 70f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::less; 71f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::list; 72f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::make_pair; 73f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::map; 74f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::multimap; 75f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::multiset; 76f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::ostream; 77f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::pair; 78f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::set; 79f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::stringstream; 80f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing std::vector; 81f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::A; 82f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::AllArgs; 83f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::AllOf; 84f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::An; 85f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::AnyOf; 86f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::ByRef; 87f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::ContainsRegex; 88f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::DoubleEq; 89f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::DoubleNear; 90f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::EndsWith; 91f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Eq; 92f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::ExplainMatchResult; 93f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Field; 94f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::FloatEq; 95f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::FloatNear; 96f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Ge; 97f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Gt; 98f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::HasSubstr; 99f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::IsEmpty; 100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::IsNull; 101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Key; 102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Le; 103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Lt; 104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::MakeMatcher; 105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::MakePolymorphicMatcher; 106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::MatchResultListener; 107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Matcher; 108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::MatcherCast; 109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::MatcherInterface; 110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Matches; 111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::MatchesRegex; 112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::NanSensitiveDoubleEq; 113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::NanSensitiveDoubleNear; 114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::NanSensitiveFloatEq; 115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::NanSensitiveFloatNear; 116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Ne; 117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Not; 118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::NotNull; 119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Pair; 120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Pointee; 121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Pointwise; 122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::PolymorphicMatcher; 123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Property; 124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Ref; 125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::ResultOf; 126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::SizeIs; 127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::StartsWith; 128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::StrCaseEq; 129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::StrCaseNe; 130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::StrEq; 131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::StrNe; 132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::StringMatchResultListener; 133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Truly; 134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::TypedEq; 135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::UnorderedPointwise; 136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::Value; 137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::WhenSorted; 138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::WhenSortedBy; 139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::_; 140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::get; 141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::DummyMatchResultListener; 142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::ElementMatcherPair; 143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::ElementMatcherPairs; 144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::ExplainMatchFailureTupleTo; 145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::FloatingEqMatcher; 146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::FormatMatcherDescription; 147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::IsReadableTypeName; 148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::JoinAsTuple; 149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::linked_ptr; 150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::MatchMatrix; 151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::RE; 152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::scoped_ptr; 153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::StreamMatchResultListener; 154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::Strings; 155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::linked_ptr; 156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::scoped_ptr; 157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::internal::string; 158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::make_tuple; 159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochusing testing::tuple; 160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For testing ExplainMatchResultTo(). 162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass GreaterThanMatcher : public MatcherInterface<int> { 163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {} 165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(ostream* os) const { 167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is > " << rhs_; 168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(int lhs, 171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int diff = lhs - rhs_; 173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (diff > 0) { 174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is " << diff << " more than " << rhs_; 175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else if (diff == 0) { 176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is the same as " << rhs_; 177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is " << -diff << " less than " << rhs_; 179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return lhs > rhs_; 182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int rhs_; 186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMatcher<int> GreaterThan(int n) { 189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakeMatcher(new GreaterThanMatcher(n)); 190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstring OfType(const string& type_name) { 193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_RTTI 194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return " (of type " + type_name + ")"; 195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else 196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ""; 197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the description of the given matcher. 201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstring Describe(const Matcher<T>& m) { 203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss; 204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m.DescribeTo(&ss); 205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ss.str(); 206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the description of the negation of the given matcher. 209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstring DescribeNegation(const Matcher<T>& m) { 211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss; 212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m.DescribeNegationTo(&ss); 213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ss.str(); 214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns the reason why x matches, or doesn't match, m. 217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename MatcherType, typename Value> 218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstring Explain(const MatcherType& m, const Value& x) { 219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ExplainMatchResult(m, x, &listener); 221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return listener.str(); 222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchResultListenerTest, StreamingWorks) { 225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener << "hi" << 5; 227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("hi5", listener.str()); 228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener.Clear(); 230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", listener.str()); 231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener << 42; 233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("42", listener.str()); 234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Streaming shouldn't crash when the underlying ostream is NULL. 236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DummyMatchResultListener dummy; 237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch dummy << "hi" << 5; 238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchResultListenerTest, CanAccessUnderlyingStream) { 241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(DummyMatchResultListener().stream() == NULL); 242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL); 243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream()); 245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchResultListenerTest, IsInterestedWorks) { 248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(StringMatchResultListener().IsInterested()); 249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested()); 250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(DummyMatchResultListener().IsInterested()); 252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested()); 253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Makes sure that the MatcherInterface<T> interface doesn't 256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// change. 257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass EvenMatcherImpl : public MatcherInterface<int> { 258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(int x, 260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return x % 2 == 0; 262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(ostream* os) const { 265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is an even number"; 266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We deliberately don't define DescribeNegationTo() and 269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // ExplainMatchResultTo() here, to make sure the definition of these 270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // two methods is optional. 271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Makes sure that the MatcherInterface API doesn't change. 274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) { 275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EvenMatcherImpl m; 276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests implementing a monomorphic matcher using MatchAndExplain(). 279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NewEvenMatcherImpl : public MatcherInterface<int> { 281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual bool MatchAndExplain(int x, MatchResultListener* listener) const { 283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool match = x % 2 == 0; 284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verifies that we can stream to a listener directly. 285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "value % " << 2; 286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener->stream() != NULL) { 287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verifies that we can stream to a listener's underlying stream 288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // too. 289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener->stream() << " == " << (x % 2); 290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return match; 292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void DescribeTo(ostream* os) const { 295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is an even number"; 296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) { 300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl); 301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(2)); 302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(3)); 303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("value % 2 == 0", Explain(m, 2)); 304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("value % 2 == 1", Explain(m, 3)); 305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests default-constructing a matcher. 308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, CanBeDefaultConstructed) { 309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m; 310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Matcher<T> can be constructed from a MatcherInterface<T>*. 313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, CanBeConstructedFromMatcherInterface) { 314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const MatcherInterface<int>* impl = new EvenMatcherImpl; 315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m(impl); 316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(4)); 317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(5)); 318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that value can be used in place of Eq(value). 321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, CanBeImplicitlyConstructedFromValue) { 322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = 5; 323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(5)); 324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(6)); 325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that NULL can be used in place of Eq(NULL). 328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) { 329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int*> m1 = NULL; 330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(NULL)); 331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(&n)); 333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that matchers are copyable. 336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, IsCopyable) { 337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests the copy constructor. 338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<bool> m1 = Eq(false); 339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(false)); 340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(true)); 341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests the assignment operator. 343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m1 = Eq(true); 344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(true)); 345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(false)); 346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Matcher<T>::DescribeTo() calls 349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherInterface<T>::DescribeTo(). 350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, CanDescribeItself) { 351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an even number", 352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(Matcher<int>(new EvenMatcherImpl))); 353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests Matcher<T>::MatchAndExplain(). 356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTest, MatchAndExplain) { 357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = GreaterThan(0); 358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener1; 359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.MatchAndExplain(42, &listener1)); 360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 42 more than 0", listener1.str()); 361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener2; 363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.MatchAndExplain(-9, &listener2)); 364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 9 less than 0", listener2.str()); 365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that a C-string literal can be implicitly converted to a 368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<string> or Matcher<const string&>. 369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) { 370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m1 = "hi"; 371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("hi")); 372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("hello")); 373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m2 = "hi"; 375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("hi")); 376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("hello")); 377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that a string object can be implicitly converted to a 380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<string> or Matcher<const string&>. 381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) { 382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m1 = string("hi"); 383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("hi")); 384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("hello")); 385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m2 = string("hi"); 387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("hi")); 388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("hello")); 389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STRING_PIECE_ 392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that a C-string literal can be implicitly converted to a 393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<StringPiece> or Matcher<const StringPiece&>. 394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) { 395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<StringPiece> m1 = "cats"; 396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("cats")); 397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("dogs")); 398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const StringPiece&> m2 = "cats"; 400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("cats")); 401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("dogs")); 402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that a string object can be implicitly converted to a 405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<StringPiece> or Matcher<const StringPiece&>. 406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromString) { 407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<StringPiece> m1 = string("cats"); 408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("cats")); 409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("dogs")); 410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const StringPiece&> m2 = string("cats"); 412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("cats")); 413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("dogs")); 414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that a StringPiece object can be implicitly converted to a 417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matcher<StringPiece> or Matcher<const StringPiece&>. 418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromStringPiece) { 419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<StringPiece> m1 = StringPiece("cats"); 420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("cats")); 421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("dogs")); 422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const StringPiece&> m2 = StringPiece("cats"); 424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("cats")); 425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("dogs")); 426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STRING_PIECE_ 428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MakeMatcher() constructs a Matcher<T> from a 430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// MatcherInterface* without requiring the user to explicitly 431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// write the type. 432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) { 433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const MatcherInterface<int>* dummy_impl = NULL; 434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = MakeMatcher(dummy_impl); 435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MakePolymorphicMatcher() can construct a polymorphic 438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matcher from its implementation using the old API. 439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst int g_bar = 1; 440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ReferencesBarOrIsZeroImpl { 441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const T& x, 444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* /* listener */) const { 445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const void* p = &x; 446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return p == &g_bar || x == 0; 447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(ostream* os) const { *os << "g_bar or zero"; } 450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(ostream* os) const { 452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "doesn't reference g_bar and is not zero"; 453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This function verifies that MakePolymorphicMatcher() returns a 457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// PolymorphicMatcher<T> where T is the argument's type. 458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochPolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() { 459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl()); 460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) { 463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Using a polymorphic matcher to match a reference type. 464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m1 = ReferencesBarOrIsZero(); 465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(0)); 466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verifies that the identity of a by-reference argument is preserved. 467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(g_bar)); 468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(1)); 469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("g_bar or zero", Describe(m1)); 470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Using a polymorphic matcher to match a value type. 472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m2 = ReferencesBarOrIsZero(); 473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0.0)); 474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(0.1)); 475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("g_bar or zero", Describe(m2)); 476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests implementing a polymorphic matcher using MatchAndExplain(). 479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PolymorphicIsEvenImpl { 481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(ostream* os) const { *os << "is even"; } 483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(ostream* os) const { 485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is odd"; 486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const T& x, MatchResultListener* listener) const { 490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verifies that we can stream to the listener directly. 491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "% " << 2; 492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (listener->stream() != NULL) { 493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verifies that we can stream to the listener's underlying stream 494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // too. 495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener->stream() << " == " << (x % 2); 496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (x % 2) == 0; 498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochPolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() { 502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(PolymorphicIsEvenImpl()); 503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) { 506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Using PolymorphicIsEven() as a Matcher<int>. 507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m1 = PolymorphicIsEven(); 508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(42)); 509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(43)); 510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is even", Describe(m1)); 511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> not_m1 = Not(m1); 513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is odd", Describe(not_m1)); 514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("% 2 == 0", Explain(m1, 42)); 516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Using PolymorphicIsEven() as a Matcher<char>. 518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<char> m2 = PolymorphicIsEven(); 519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches('\x42')); 520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches('\x43')); 521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is even", Describe(m2)); 522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<char> not_m2 = Not(m2); 524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is odd", Describe(not_m2)); 525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("% 2 == 0", Explain(m2, '\x42')); 527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<T>(m) works when m is a polymorphic matcher. 530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromPolymorphicMatcher) { 531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = MatcherCast<int>(Eq(5)); 532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(5)); 533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(6)); 534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For testing casting matchers between compatible types. 537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass IntValue { 538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // An int can be statically (although not implicitly) cast to a 540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // IntValue. 541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit IntValue(int a_value) : value_(a_value) {} 542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value() const { return value_; } 544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value_; 546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For testing casting matchers between compatible types. 549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool IsPositiveIntValue(const IntValue& foo) { 550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return foo.value() > 0; 551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T 554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// can be statically converted to U. 555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromCompatibleType) { 556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = Eq(2.0); 557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(2)); 559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(3)); 560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<IntValue> m3 = Truly(IsPositiveIntValue); 562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m4 = MatcherCast<int>(m3); 563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // In the following, the arguments 1 and 0 are statically converted 564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to IntValue objects, and then tested by the IsPositiveIntValue() 565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // predicate. 566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m4.Matches(1)); 567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m4.Matches(0)); 568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>. 571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromConstReferenceToNonReference) { 572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m1 = Eq(0); 573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0)); 575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(1)); 576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>. 579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromReferenceToNonReference) { 580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m1 = Eq(0); 581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0)); 583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(1)); 584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>. 587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromNonReferenceToConstReference) { 588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(0); 589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m2 = MatcherCast<const int&>(m1); 590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0)); 591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(1)); 592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<T&>(m) works when m is a Matcher<T>. 595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromNonReferenceToReference) { 596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(0); 597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = MatcherCast<int&>(m1); 598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(n)); 600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = 1; 601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(n)); 602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<T>. 605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromSameType) { 606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(0); 607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0)); 609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(1)); 610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implicitly convertible from any type. 613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct ConvertibleFromAny { 614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConvertibleFromAny(int a_value) : value(a_value) {} 615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConvertibleFromAny(const T& /*a_value*/) : value(-1) { 617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ADD_FAILURE() << "Conversion constructor called"; 618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value; 620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) { 623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return a.value == b.value; 624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochostream& operator<<(ostream& os, const ConvertibleFromAny& a) { 627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return os << a.value; 628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, ConversionConstructorIsUsed) { 631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1); 632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(ConvertibleFromAny(1))); 633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(ConvertibleFromAny(2))); 634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, FromConvertibleFromAny) { 637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<ConvertibleFromAny> m = 638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1))); 639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(ConvertibleFromAny(1))); 640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(ConvertibleFromAny(2))); 641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct IntReferenceWrapper { 644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch IntReferenceWrapper(const int& a_value) : value(&a_value) {} 645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int* value; 646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) { 649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return a.value == b.value; 650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherCastTest, ValueIsNotCopied) { 653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 42; 654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n); 655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verify that the matcher holds a reference to n, not to its temporary copy. 656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(n)); 657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Base { 660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual ~Base() {} 662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base() {} 663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(Base); 665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Derived : public Base { 668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived() : Base() {} 670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int i; 671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass OtherDerived : public Base {}; 674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher. 676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromPolymorphicMatcher) { 677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<char> m2 = SafeMatcherCast<char>(Eq(32)); 678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(' ')); 679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches('\n')); 680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where 683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// T and U are arithmetic types and T can be losslessly converted to 684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// U. 685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) { 686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = DoubleEq(1.0); 687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m2 = SafeMatcherCast<float>(m1); 688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(1.0f)); 689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(2.0f)); 690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a')); 692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches('a')); 693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches('b')); 694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U 697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// are pointers or references to a derived and a base class, correspondingly. 698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromBaseClass) { 699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived d, d2; 700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Base*> m1 = Eq(&d); 701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1); 702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(&d)); 703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(&d2)); 704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Base&> m3 = Ref(d); 706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3); 707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m4.Matches(d)); 708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m4.Matches(d2)); 709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>. 712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromConstReferenceToReference) { 713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m1 = Ref(n); 715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = SafeMatcherCast<int&>(m1); 716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n1 = 0; 717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(n)); 718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(n1)); 719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>. 722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromNonReferenceToConstReference) { 723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(0); 724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1); 725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0)); 726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(1)); 727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>. 730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromNonReferenceToReference) { 731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(0); 732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = SafeMatcherCast<int&>(m1); 733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(n)); 735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = 1; 736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(n)); 737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>. 740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromSameType) { 741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(0); 742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m2 = SafeMatcherCast<int>(m1); 743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0)); 744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(1)); 745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, ConversionConstructorIsUsed) { 748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1); 749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(ConvertibleFromAny(1))); 750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(ConvertibleFromAny(2))); 751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, FromConvertibleFromAny) { 754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<ConvertibleFromAny> m = 755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1))); 756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(ConvertibleFromAny(1))); 757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(ConvertibleFromAny(2))); 758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SafeMatcherCastTest, ValueIsNotCopied) { 761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 42; 762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n); 763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verify that the matcher holds a reference to n, not to its temporary copy. 764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(n)); 765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExpectThat, TakesLiterals) { 768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(1, 1); 769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(1.0, 1.0); 770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(string(), ""); 771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExpectThat, TakesFunctions) { 774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch struct Helper { 775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void Func() {} 776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void (*func)() = Helper::Func; 778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(func, Helper::Func); 779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(func, &Helper::Func); 780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that A<T>() matches any value of type T. 783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ATest, MatchesAnyValue) { 784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests a matcher for a value type. 785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = A<double>(); 786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(91.43)); 787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(-15.32)); 788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests a matcher for a reference type. 790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int a = 2; 791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int b = -6; 792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = A<int&>(); 793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(a)); 794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(b)); 795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ATest, WorksForDerivedClass) { 798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base base; 799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(&base, A<Base*>()); 801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>()); 802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(&derived, A<Base*>()); 803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(&derived, A<Derived*>()); 804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that A<T>() describes itself properly. 807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ATest, CanDescribeSelf) { 808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", Describe(A<bool>())); 809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that An<T>() matches any value of type T. 812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnTest, MatchesAnyValue) { 813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests a matcher for a value type. 814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = An<int>(); 815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(9143)); 816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(-1532)); 817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests a matcher for a reference type. 819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int a = 2; 820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int b = -6; 821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = An<int&>(); 822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(a)); 823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(b)); 824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that An<T>() describes itself properly. 827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnTest, CanDescribeSelf) { 828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", Describe(An<int>())); 829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that _ can be used as a matcher for any type and matches any 832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// value of that type. 833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnderscoreTest, MatchesAnyValue) { 834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Uses _ as a matcher for a value type. 835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = _; 836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(123)); 837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(-242)); 838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Uses _ as a matcher for a reference type. 840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool a = false; 841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool b = true; 842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const bool&> m2 = _; 843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(a)); 844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(b)); 845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that _ describes itself properly. 848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnderscoreTest, CanDescribeSelf) { 849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = _; 850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", Describe(m)); 851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Eq(x) matches any value equal to x. 854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EqTest, MatchesEqualValue) { 855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 2 C-strings with same content but different addresses. 856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char a1[] = "hi"; 857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char a2[] = "hi"; 858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m1 = Eq(a1); 860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(a1)); 861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(a2)); 862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Eq(v) describes itself properly. 865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Unprintable { 867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Unprintable() : c_('a') {} 869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator==(const Unprintable& /* rhs */) { return true; } 871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char c_; 873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EqTest, CanDescribeSelf) { 876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Unprintable> m = Eq(Unprintable()); 877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to 1-byte object <61>", Describe(m)); 878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Eq(v) can be used to match any type that supports 881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// comparing with type T, where T is v's type. 882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EqTest, IsPolymorphic) { 883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Eq(1); 884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(1)); 885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(2)); 886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<char> m2 = Eq(1); 888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches('\1')); 889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches('a')); 890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that TypedEq<T>(v) matches values of type T that's equal to v. 893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TypedEqTest, ChecksEqualityForGivenType) { 894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<char> m1 = TypedEq<char>('a'); 895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches('a')); 896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches('b')); 897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m2 = TypedEq<int>(6); 899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(6)); 900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(7)); 901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that TypedEq(v) describes itself properly. 904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TypedEqTest, CanDescribeSelf) { 905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2))); 906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that TypedEq<T>(v) has type Matcher<T>. 909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Type<T>::IsTypeOf(v) compiles iff the type of value v is T, where T 911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is a "bare" type (i.e. not in the form of const U or U&). If v's 912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type is not T, the compiler will generate a message about 913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "undefined referece". 914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct Type { 916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static bool IsTypeOf(const T& /* v */) { return true; } 917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T2> 919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static void IsTypeOf(T2 v); 920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TypedEqTest, HasSpecifiedType) { 923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Verfies that the type of TypedEq<T>(v) is Matcher<T>. 924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5)); 925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5)); 926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ge(v) matches anything >= v. 929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GeTest, ImplementsGreaterThanOrEqual) { 930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Ge(0); 931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(1)); 932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(0)); 933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(-1)); 934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ge(v) describes itself properly. 937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GeTest, CanDescribeSelf) { 938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Ge(5); 939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is >= 5", Describe(m)); 940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Gt(v) matches anything > v. 943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GtTest, ImplementsGreaterThan) { 944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = Gt(0); 945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(1.0)); 946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(0.0)); 947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(-1.0)); 948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Gt(v) describes itself properly. 951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GtTest, CanDescribeSelf) { 952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Gt(5); 953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is > 5", Describe(m)); 954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Le(v) matches anything <= v. 957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(LeTest, ImplementsLessThanOrEqual) { 958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<char> m1 = Le('b'); 959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches('a')); 960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches('b')); 961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches('c')); 962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Le(v) describes itself properly. 965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(LeTest, CanDescribeSelf) { 966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Le(5); 967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is <= 5", Describe(m)); 968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Lt(v) matches anything < v. 971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(LtTest, ImplementsLessThan) { 972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m1 = Lt("Hello"); 973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("Abc")); 974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("Hello")); 975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches("Hello, world!")); 976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Lt(v) describes itself properly. 979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(LtTest, CanDescribeSelf) { 980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Lt(5); 981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is < 5", Describe(m)); 982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ne(v) matches anything != v. 985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NeTest, ImplementsNotEqual) { 986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m1 = Ne(0); 987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(1)); 988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(-1)); 989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(0)); 990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ne(v) describes itself properly. 993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NeTest, CanDescribeSelf) { 994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Ne(5); 995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to 5", Describe(m)); 996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that IsNull() matches any NULL pointer of any type. 999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsNullTest, MatchesNullPointer) { 1000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int*> m1 = IsNull(); 1001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int* p1 = NULL; 1002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 1003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(p1)); 1004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(&n)); 1005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m2 = IsNull(); 1007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* p2 = NULL; 1008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(p2)); 1009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("hi")); 1010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if !GTEST_OS_SYMBIAN 1012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Nokia's Symbian compiler generates: 1013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // gmock-matchers.h: ambiguous access to overloaded function 1014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)' 1015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing:: 1016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // MatcherInterface<void *> *)' 1017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // gmock-matchers.h: (point of instantiation: 'testing:: 1018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()') 1019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // gmock-matchers.h: (instantiating: 'testing::PolymorphicMatc 1020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<void*> m3 = IsNull(); 1021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void* p3 = NULL; 1022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(p3)); 1023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef))); 1024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 1025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsNullTest, LinkedPtr) { 1028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<linked_ptr<int> > m = IsNull(); 1029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<int> null_p; 1030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<int> non_null_p(new int); 1031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(null_p)); 1033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(non_null_p)); 1034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsNullTest, ReferenceToConstLinkedPtr) { 1037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const linked_ptr<double>&> m = IsNull(); 1038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<double> null_p; 1039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<double> non_null_p(new double); 1040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(null_p)); 1042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(non_null_p)); 1043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 1046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsNullTest, StdFunction) { 1047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<std::function<void()>> m = IsNull(); 1048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(std::function<void()>())); 1050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches([]{})); 1051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 1053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that IsNull() describes itself properly. 1055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsNullTest, CanDescribeSelf) { 1056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int*> m = IsNull(); 1057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is NULL", Describe(m)); 1058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't NULL", DescribeNegation(m)); 1059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that NotNull() matches any non-NULL pointer of any type. 1062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotNullTest, MatchesNonNullPointer) { 1063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int*> m1 = NotNull(); 1064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int* p1 = NULL; 1065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 1066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(p1)); 1067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(&n)); 1068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m2 = NotNull(); 1070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* p2 = NULL; 1071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(p2)); 1072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("hi")); 1073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotNullTest, LinkedPtr) { 1076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<linked_ptr<int> > m = NotNull(); 1077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<int> null_p; 1078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<int> non_null_p(new int); 1079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(null_p)); 1081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(non_null_p)); 1082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotNullTest, ReferenceToConstLinkedPtr) { 1085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const linked_ptr<double>&> m = NotNull(); 1086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<double> null_p; 1087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const linked_ptr<double> non_null_p(new double); 1088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(null_p)); 1090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(non_null_p)); 1091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 1094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotNullTest, StdFunction) { 1095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<std::function<void()>> m = NotNull(); 1096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches([]{})); 1098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(std::function<void()>())); 1099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 1101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that NotNull() describes itself properly. 1103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotNullTest, CanDescribeSelf) { 1104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int*> m = NotNull(); 1105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't NULL", Describe(m)); 1106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ref(variable) matches an argument that references 1109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 'variable'. 1110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(RefTest, MatchesSameVariable) { 1111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int a = 0; 1112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int b = 0; 1113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m = Ref(a); 1114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 1115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(b)); 1116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ref(variable) describes itself properly. 1119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(RefTest, CanDescribeSelf) { 1120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 5; 1121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m = Ref(n); 1122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss; 1123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ss << "references the variable @" << &n << " 5"; 1124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(string(ss.str()), Describe(m)); 1125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Test that Ref(non_const_varialbe) can be used as a matcher for a 1128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// const reference. 1129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(RefTest, CanBeUsedAsMatcherForConstReference) { 1130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int a = 0; 1131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int b = 0; 1132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m = Ref(a); 1133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 1134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(b)); 1135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ref(variable) is covariant, i.e. Ref(derived) can be 1138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// used wherever Ref(base) can be used (Ref(derived) is a sub-type 1139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// of Ref(base), but not vice versa. 1140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(RefTest, IsCovariant) { 1142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base base, base2; 1143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 1144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Base&> m1 = Ref(base); 1145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(base)); 1146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(base2)); 1147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(derived)); 1148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m1 = Ref(derived); 1150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(derived)); 1151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(base)); 1152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(base2)); 1153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(RefTest, ExplainsResult) { 1156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 1157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n), 1158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StartsWith("which is located @")); 1159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int m = 0; 1161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m), 1162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StartsWith("which is located @")); 1163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests string comparison matchers. 1166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrEqTest, MatchesEqualString) { 1168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m = StrEq(string("Hello")); 1169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches("Hello")); 1170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches("hello")); 1171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m2 = StrEq("Hello"); 1174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("Hello")); 1175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("Hi")); 1176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrEqTest, CanDescribeSelf) { 1179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3"); 1180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"", 1181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 1182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string str("01204500800"); 1184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[3] = '\0'; 1185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m2 = StrEq(str); 1186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2)); 1187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = '\0'; 1188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m3 = StrEq(str); 1189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3)); 1190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrNeTest, MatchesUnequalString) { 1193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m = StrNe("Hello"); 1194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches("")); 1195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches("Hello")); 1197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m2 = StrNe(string("Hello")); 1199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("hello")); 1200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("Hello")); 1201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrNeTest, CanDescribeSelf) { 1204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m = StrNe("Hi"); 1205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to \"Hi\"", Describe(m)); 1206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) { 1209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m = StrCaseEq(string("Hello")); 1210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches("Hello")); 1211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches("hello")); 1212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches("Hi")); 1213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m2 = StrCaseEq("Hello"); 1216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("hello")); 1217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("Hi")); 1218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) { 1221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string str1("oabocdooeoo"); 1222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string str2("OABOCDOOEOO"); 1223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m0 = StrCaseEq(str1); 1224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m0.Matches(str2 + string(1, '\0'))); 1225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[3] = str2[3] = '\0'; 1227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m1 = StrCaseEq(str1); 1228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(str2)); 1229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[0] = str1[6] = str1[7] = str1[10] = '\0'; 1231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str2[0] = str2[6] = str2[7] = str2[10] = '\0'; 1232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m2 = StrCaseEq(str1); 1233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[9] = str2[9] = '\0'; 1234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(str2)); 1235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> m3 = StrCaseEq(str1); 1237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(str2)); 1238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(str2 + "x")); 1240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str2.append(1, '\0'); 1241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(str2)); 1242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(string(str2, 0, 9))); 1243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrCaseEqTest, CanDescribeSelf) { 1246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m = StrCaseEq("Hi"); 1247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m)); 1248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) { 1251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m = StrCaseNe("Hello"); 1252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches("Hi")); 1253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches("Hello")); 1255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches("hello")); 1256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m2 = StrCaseNe(string("Hello")); 1258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("")); 1259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("Hello")); 1260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StrCaseNeTest, CanDescribeSelf) { 1263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m = StrCaseNe("Hi"); 1264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m)); 1265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr() works for matching string-typed values. 1268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(HasSubstrTest, WorksForStringClasses) { 1269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<string> m1 = HasSubstr("foo"); 1270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(string("I love food."))); 1271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(string("tofo"))); 1272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const std::string&> m2 = HasSubstr("foo"); 1274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(std::string("I love food."))); 1275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(std::string("tofo"))); 1276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr() works for matching C-string-typed values. 1279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(HasSubstrTest, WorksForCStrings) { 1280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<char*> m1 = HasSubstr("foo"); 1281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food."))); 1282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo"))); 1283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const char*> m2 = HasSubstr("foo"); 1286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("I love food.")); 1287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("tofo")); 1288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(NULL)); 1289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr(s) describes itself properly. 1292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(HasSubstrTest, CanDescribeSelf) { 1293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<string> m = HasSubstr("foo\n\""); 1294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m)); 1295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(KeyTest, CanDescribeSelf) { 1298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const pair<std::string, int>&> m = Key("foo"); 1299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m)); 1300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m)); 1301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(KeyTest, ExplainsResult) { 1304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<pair<int, bool> > m = Key(GreaterThan(10)); 1305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose first field is a value which is 5 less than 10", 1306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, make_pair(5, true))); 1307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose first field is a value which is 5 more than 10", 1308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, make_pair(15, true))); 1309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(KeyTest, MatchesCorrectly) { 1312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch pair<int, std::string> p(25, "foo"); 1313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Key(25)); 1314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Key(42))); 1315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Key(Ge(20))); 1316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Key(Lt(25)))); 1317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(KeyTest, SafelyCastsInnerMatcher) { 1320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> is_positive = Gt(0); 1321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> is_negative = Lt(0); 1322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch pair<char, bool> p('a', true); 1323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Key(is_positive)); 1324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Key(is_negative))); 1325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(KeyTest, InsideContainsUsingMap) { 1328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<int, char> container; 1329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(1, 'a')); 1330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(2, 'b')); 1331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(4, 'c')); 1332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Key(1))); 1333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(Contains(Key(3)))); 1334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(KeyTest, InsideContainsUsingMultimap) { 1337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch multimap<int, char> container; 1338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(1, 'a')); 1339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(2, 'b')); 1340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(4, 'c')); 1341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(Contains(Key(25)))); 1343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(25, 'd')); 1344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Key(25))); 1345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(25, 'e')); 1346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Key(25))); 1347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Key(1))); 1349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(Contains(Key(3)))); 1350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PairTest, Typing) { 1353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Test verifies the following type conversions can be compiled. 1354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42); 1355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const pair<const char*, int> > m2 = Pair("foo", 42); 1356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<pair<const char*, int> > m3 = Pair("foo", 42); 1357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<pair<int, const std::string> > m4 = Pair(25, "42"); 1359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<pair<const std::string, int> > m5 = Pair("25", 42); 1360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PairTest, CanDescribeSelf) { 1363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42); 1364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has a first field that is equal to \"foo\"" 1365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ", and has a second field that is equal to 42", 1366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m1)); 1367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has a first field that isn't equal to \"foo\"" 1368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ", or has a second field that isn't equal to 42", 1369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m1)); 1370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Double and triple negation (1 or 2 times not and description of negation). 1371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42)); 1372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has a first field that isn't equal to 13" 1373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ", and has a second field that is equal to 42", 1374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m2)); 1375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PairTest, CanExplainMatchResultTo) { 1378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If neither field matches, Pair() should explain about the first 1379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // field. 1380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0)); 1381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose first field does not match, which is 1 less than 0", 1382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, make_pair(-1, -2))); 1383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If the first field matches but the second doesn't, Pair() should 1385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain about the second field. 1386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose second field does not match, which is 2 less than 0", 1387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, make_pair(1, -2))); 1388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If the first field doesn't match but the second does, Pair() 1390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // should explain about the first field. 1391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose first field does not match, which is 1 less than 0", 1392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, make_pair(-1, 2))); 1393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If both fields match, Pair() should explain about them both. 1395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose both fields match, where the first field is a value " 1396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "which is 1 more than 0, and the second field is a value " 1397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "which is 2 more than 0", 1398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, make_pair(1, 2))); 1399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If only the first match has an explanation, only this explanation should 1401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // be printed. 1402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0); 1403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose both fields match, where the first field is a value " 1404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "which is 1 more than 0", 1405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(explain_first, make_pair(1, 0))); 1406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // If only the second match has an explanation, only this explanation should 1408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // be printed. 1409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0)); 1410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose both fields match, where the second field is a value " 1411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "which is 1 more than 0", 1412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(explain_second, make_pair(0, 1))); 1413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PairTest, MatchesCorrectly) { 1416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch pair<int, std::string> p(25, "foo"); 1417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Both fields match. 1419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Pair(25, "foo")); 1420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o"))); 1421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 'first' doesnt' match, but 'second' matches. 1423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(42, "foo"))); 1424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(Lt(25), "foo"))); 1425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 'first' matches, but 'second' doesn't match. 1427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(25, "bar"))); 1428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(25, Not("foo")))); 1429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Neither field matches. 1431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(13, "bar"))); 1432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a")))); 1433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PairTest, SafelyCastsInnerMatchers) { 1436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> is_positive = Gt(0); 1437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> is_negative = Lt(0); 1438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch pair<char, bool> p('a', true); 1439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Pair(is_positive, _)); 1440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(is_negative, _))); 1441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Pair(_, is_positive)); 1442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(p, Not(Pair(_, is_negative))); 1443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PairTest, InsideContainsUsingMap) { 1446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<int, char> container; 1447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(1, 'a')); 1448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(2, 'b')); 1449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair(4, 'c')); 1450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Pair(1, 'a'))); 1451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Pair(1, _))); 1452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Contains(Pair(_, 'a'))); 1453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(Contains(Pair(3, _)))); 1454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests StartsWith(s). 1457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StartsWithTest, MatchesStringWithGivenPrefix) { 1459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const char*> m1 = StartsWith(string("")); 1460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("Hi")); 1461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("")); 1462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const string&> m2 = StartsWith("Hi"); 1465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("Hi")); 1466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("Hi Hi!")); 1467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("High")); 1468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("H")); 1469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(" Hi")); 1470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StartsWithTest, CanDescribeSelf) { 1473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::string> m = StartsWith("Hi"); 1474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("starts with \"Hi\"", Describe(m)); 1475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests EndsWith(s). 1478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EndsWithTest, MatchesStringWithGivenSuffix) { 1480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const char*> m1 = EndsWith(""); 1481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("Hi")); 1482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("")); 1483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const string&> m2 = EndsWith(string("Hi")); 1486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("Hi")); 1487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("Wow Hi Hi")); 1488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("Super Hi")); 1489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("i")); 1490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("Hi ")); 1491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EndsWithTest, CanDescribeSelf) { 1494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::string> m = EndsWith("Hi"); 1495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("ends with \"Hi\"", Describe(m)); 1496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests MatchesRegex(). 1499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) { 1501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const char*> m1 = MatchesRegex("a.*z"); 1502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("az")); 1503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("abcz")); 1504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z")); 1507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("azbz")); 1508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("az1")); 1509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("1az")); 1510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchesRegexTest, CanDescribeSelf) { 1513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::string> m1 = MatchesRegex(string("Hi.*")); 1514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1)); 1515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m2 = MatchesRegex(new RE("a.*")); 1517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2)); 1518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests ContainsRegex(). 1521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainsRegexTest, MatchesStringContainingGivenRegex) { 1523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const char*> m1 = ContainsRegex(string("a.*z")); 1524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("az")); 1525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches("0abcz1")); 1526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z")); 1529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("azbz")); 1530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches("az1")); 1531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches("1a")); 1532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainsRegexTest, CanDescribeSelf) { 1535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::string> m1 = ContainsRegex("Hi.*"); 1536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1)); 1537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> m2 = ContainsRegex(new RE("a.*")); 1539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2)); 1540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests for wide strings. 1543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_WSTRING 1544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrEqTest, MatchesEqual) { 1545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello")); 1546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m2 = StrEq(L"Hello"); 1551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hello")); 1552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D")); 1556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E")); 1557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::wstring str(L"01204500800"); 1559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[3] = L'\0'; 1560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m4 = StrEq(str); 1561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m4.Matches(str)); 1562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m5 = StrEq(str); 1564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m5.Matches(str)); 1565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrEqTest, CanDescribeSelf) { 1568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v"); 1569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"", 1570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 1571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"", 1574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m2)); 1575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::wstring str(L"01204500800"); 1577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[3] = L'\0'; 1578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m4 = StrEq(str); 1579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4)); 1580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m5 = StrEq(str); 1582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5)); 1583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrNeTest, MatchesUnequalString) { 1586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hello"); 1587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"")); 1588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello")); 1592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrNeTest, CanDescribeSelf) { 1597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hi"); 1598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m)); 1599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) { 1602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello")); 1603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"hello")); 1605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"Hi")); 1606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello"); 1609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) { 1614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::wstring str1(L"oabocdooeoo"); 1615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::wstring str2(L"OABOCDOOEOO"); 1616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m0 = StrCaseEq(str1); 1617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0'))); 1618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[3] = str2[3] = L'\0'; 1620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m1 = StrCaseEq(str1); 1621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(str2)); 1622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[0] = str1[6] = str1[7] = str1[10] = L'\0'; 1624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str2[0] = str2[6] = str2[7] = str2[10] = L'\0'; 1625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m2 = StrCaseEq(str1); 1626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[9] = str2[9] = L'\0'; 1627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(str2)); 1628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring&> m3 = StrCaseEq(str1); 1630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(str2)); 1631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(str2 + L"x")); 1633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str2.append(1, L'\0'); 1634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(str2)); 1635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9))); 1636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrCaseEqTest, CanDescribeSelf) { 1639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::std::wstring> m = StrCaseEq(L"Hi"); 1640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m)); 1641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) { 1644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hello"); 1645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"Hi")); 1646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello")); 1651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"")); 1652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStrCaseNeTest, CanDescribeSelf) { 1656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hi"); 1657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m)); 1658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr() works for matching wstring-typed values. 1661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideHasSubstrTest, WorksForStringClasses) { 1662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher< ::std::wstring> m1 = HasSubstr(L"foo"); 1663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food."))); 1664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo"))); 1665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo"); 1667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food."))); 1668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo"))); 1669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr() works for matching C-wide-string-typed values. 1672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideHasSubstrTest, WorksForCStrings) { 1673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<wchar_t*> m1 = HasSubstr(L"foo"); 1674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food."))); 1675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo"))); 1676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const wchar_t*> m2 = HasSubstr(L"foo"); 1679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"I love food.")); 1680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"tofo")); 1681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(NULL)); 1682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr(s) describes itself properly. 1685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideHasSubstrTest, CanDescribeSelf) { 1686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::std::wstring> m = HasSubstr(L"foo\n\""); 1687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m)); 1688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests StartsWith(s). 1691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) { 1693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L"")); 1694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi"); 1699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi Hi!")); 1701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"High")); 1702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"H")); 1703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L" Hi")); 1704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideStartsWithTest, CanDescribeSelf) { 1707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring> m = StartsWith(L"Hi"); 1708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("starts with L\"Hi\"", Describe(m)); 1709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests EndsWith(s). 1712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) { 1714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const wchar_t*> m1 = EndsWith(L""); 1715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi")); 1720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Wow Hi Hi")); 1722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Super Hi")); 1723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"i")); 1724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi ")); 1725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StdWideEndsWithTest, CanDescribeSelf) { 1728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::std::wstring> m = EndsWith(L"Hi"); 1729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("ends with L\"Hi\"", Describe(m)); 1730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_WSTRING 1733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_GLOBAL_WSTRING 1735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrEqTest, MatchesEqual) { 1736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello")); 1737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m2 = StrEq(L"Hello"); 1742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hello")); 1743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D")); 1747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E")); 1748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::wstring str(L"01204500800"); 1750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[3] = L'\0'; 1751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m4 = StrEq(str); 1752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m4.Matches(str)); 1753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m5 = StrEq(str); 1755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m5.Matches(str)); 1756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrEqTest, CanDescribeSelf) { 1759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v"); 1760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"", 1761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 1762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"", 1765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m2)); 1766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::wstring str(L"01204500800"); 1768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[3] = L'\0'; 1769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m4 = StrEq(str); 1770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4)); 1771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m5 = StrEq(str); 1773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5)); 1774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrNeTest, MatchesUnequalString) { 1777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hello"); 1778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"")); 1779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello")); 1783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrNeTest, CanDescribeSelf) { 1788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hi"); 1789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m)); 1790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) { 1793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrCaseEq(::wstring(L"Hello")); 1794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"hello")); 1796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"Hi")); 1797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello"); 1800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) { 1805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::wstring str1(L"oabocdooeoo"); 1806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::wstring str2(L"OABOCDOOEOO"); 1807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m0 = StrCaseEq(str1); 1808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m0.Matches(str2 + ::wstring(1, L'\0'))); 1809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[3] = str2[3] = L'\0'; 1811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m1 = StrCaseEq(str1); 1812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(str2)); 1813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[0] = str1[6] = str1[7] = str1[10] = L'\0'; 1815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str2[0] = str2[6] = str2[7] = str2[10] = L'\0'; 1816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m2 = StrCaseEq(str1); 1817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str1[9] = str2[9] = L'\0'; 1818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(str2)); 1819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring&> m3 = StrCaseEq(str1); 1821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(str2)); 1822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(str2 + L"x")); 1824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch str2.append(1, L'\0'); 1825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(str2)); 1826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(::wstring(str2, 0, 9))); 1827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrCaseEqTest, CanDescribeSelf) { 1830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::wstring> m = StrCaseEq(L"Hi"); 1831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m)); 1832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) { 1835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hello"); 1836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(L"Hi")); 1837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello")); 1842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"")); 1843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStrCaseNeTest, CanDescribeSelf) { 1847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hi"); 1848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m)); 1849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr() works for matching wstring-typed values. 1852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideHasSubstrTest, WorksForStringClasses) { 1853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher< ::wstring> m1 = HasSubstr(L"foo"); 1854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(::wstring(L"I love food."))); 1855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(::wstring(L"tofo"))); 1856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::wstring&> m2 = HasSubstr(L"foo"); 1858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(::wstring(L"I love food."))); 1859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(::wstring(L"tofo"))); 1860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr() works for matching C-wide-string-typed values. 1863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideHasSubstrTest, WorksForCStrings) { 1864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<wchar_t*> m1 = HasSubstr(L"foo"); 1865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food."))); 1866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo"))); 1867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const wchar_t*> m2 = HasSubstr(L"foo"); 1870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"I love food.")); 1871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"tofo")); 1872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(NULL)); 1873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that HasSubstr(s) describes itself properly. 1876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideHasSubstrTest, CanDescribeSelf) { 1877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher< ::wstring> m = HasSubstr(L"foo\n\""); 1878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m)); 1879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests StartsWith(s). 1882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStartsWithTest, MatchesStringWithGivenPrefix) { 1884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L"")); 1885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::wstring&> m2 = StartsWith(L"Hi"); 1890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi Hi!")); 1892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"High")); 1893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"H")); 1894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L" Hi")); 1895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideStartsWithTest, CanDescribeSelf) { 1898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring> m = StartsWith(L"Hi"); 1899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("starts with L\"Hi\"", Describe(m)); 1900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests EndsWith(s). 1903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideEndsWithTest, MatchesStringWithGivenSuffix) { 1905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const wchar_t*> m1 = EndsWith(L""); 1906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi")); 1911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Wow Hi Hi")); 1913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(L"Super Hi")); 1914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"i")); 1915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi ")); 1916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(GlobalWideEndsWithTest, CanDescribeSelf) { 1919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const ::wstring> m = EndsWith(L"Hi"); 1920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("ends with L\"Hi\"", Describe(m)); 1921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_GLOBAL_WSTRING 1924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef ::testing::tuple<long, int> Tuple2; // NOLINT 1927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Eq() matches a 2-tuple where the first field == the 1929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second field. 1930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Eq2Test, MatchesEqualArguments) { 1931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Eq(); 1932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 5))); 1933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 6))); 1934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Eq() describes itself properly. 1937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Eq2Test, CanDescribeSelf) { 1938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Eq(); 1939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("are an equal pair", Describe(m)); 1940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ge() matches a 2-tuple where the first field >= the 1943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second field. 1944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Ge2Test, MatchesGreaterThanOrEqualArguments) { 1945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Ge(); 1946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 4))); 1947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 5))); 1948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 6))); 1949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ge() describes itself properly. 1952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Ge2Test, CanDescribeSelf) { 1953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Ge(); 1954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("are a pair where the first >= the second", Describe(m)); 1955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Gt() matches a 2-tuple where the first field > the 1958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second field. 1959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Gt2Test, MatchesGreaterThanArguments) { 1960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Gt(); 1961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 4))); 1962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 5))); 1963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 6))); 1964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Gt() describes itself properly. 1967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Gt2Test, CanDescribeSelf) { 1968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Gt(); 1969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("are a pair where the first > the second", Describe(m)); 1970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Le() matches a 2-tuple where the first field <= the 1973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second field. 1974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Le2Test, MatchesLessThanOrEqualArguments) { 1975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Le(); 1976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 6))); 1977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 5))); 1978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 4))); 1979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Le() describes itself properly. 1982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Le2Test, CanDescribeSelf) { 1983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Le(); 1984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("are a pair where the first <= the second", Describe(m)); 1985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Lt() matches a 2-tuple where the first field < the 1988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second field. 1989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Lt2Test, MatchesLessThanArguments) { 1990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Lt(); 1991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 6))); 1992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 5))); 1993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 4))); 1994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 1995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 1996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Lt() describes itself properly. 1997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Lt2Test, CanDescribeSelf) { 1998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Lt(); 1999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("are a pair where the first < the second", Describe(m)); 2000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ne() matches a 2-tuple where the first field != the 2003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// second field. 2004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Ne2Test, MatchesUnequalArguments) { 2005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Ne(); 2006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 6))); 2007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 4))); 2008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 5))); 2009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Ne() describes itself properly. 2012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(Ne2Test, CanDescribeSelf) { 2013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Tuple2&> m = Ne(); 2014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("are an unequal pair", Describe(m)); 2015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Not(m) matches any value that doesn't match m. 2018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotTest, NegatesMatcher) { 2019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Not(Eq(2)); 2021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(3)); 2022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(2)); 2023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Not(m) describes itself properly. 2026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotTest, CanDescribeSelf) { 2027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Not(Eq(5)); 2028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't equal to 5", Describe(m)); 2029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that monomorphic matchers are safely cast by the Not matcher. 2032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) { 2033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // greater_than_5 is a monomorphic matcher. 2034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> greater_than_5 = Gt(5); 2035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m = Not(greater_than_5); 2037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = Not(greater_than_5); 2038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m3 = Not(m); 2039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Helper to allow easy testing of AllOf matchers with num parameters. 2042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid AllOfMatches(int num, const Matcher<int>& m) { 2043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SCOPED_TRACE(Describe(m)); 2044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(0)); 2045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (int i = 1; i <= num; ++i) { 2046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(i)); 2047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(num + 1)); 2049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that AllOf(m1, ..., mn) matches any value that matches all of 2052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the given matchers. 2053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllOfTest, MatchesWhenAllMatch) { 2054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Le(2), Ge(1)); 2056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(1)); 2057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(2)); 2058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(3)); 2060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2)); 2062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(3)); 2063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(2)); 2064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1)); 2065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3)); 2068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(4)); 2069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(3)); 2070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(2)); 2071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1)); 2072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7)); 2075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(0)); 2076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(1)); 2077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(3)); 2078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The following tests for varying number of sub-matchers. Due to the way 2080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the sub-matchers are handled it is enough to test every sub-matcher once 2081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // with sub-matchers using the same matcher type. Varying matcher types are 2082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // checked for above. 2083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(2, AllOf(Ne(1), Ne(2))); 2084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3))); 2085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4))); 2086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5))); 2087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6))); 2088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7))); 2089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), 2090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(8))); 2091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), 2092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(8), Ne(9))); 2093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), 2094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(9), Ne(10))); 2095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 2098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests the variadic version of the AllOfMatcher. 2099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllOfTest, VariadicMatchesWhenAllMatch) { 2100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Make sure AllOf is defined in the right namespace and does not depend on 2101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // ADL. 2102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); 2103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), 2104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(9), Ne(10), Ne(11)); 2105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11))))))))))")); 2106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(11, m); 2107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllOfMatches(50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), 2108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(9), Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15), 2109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(16), Ne(17), Ne(18), Ne(19), Ne(20), Ne(21), Ne(22), 2110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(23), Ne(24), Ne(25), Ne(26), Ne(27), Ne(28), Ne(29), 2111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(30), Ne(31), Ne(32), Ne(33), Ne(34), Ne(35), Ne(36), 2112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(37), Ne(38), Ne(39), Ne(40), Ne(41), Ne(42), Ne(43), 2113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49), 2114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Ne(50))); 2115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 2118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that AllOf(m1, ..., mn) describes itself properly. 2120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllOfTest, CanDescribeSelf) { 2121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Le(2), Ge(1)); 2123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m)); 2124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2)); 2126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(is > 0) and " 2127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 1) and " 2128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 2))", 2129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3)); 2133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((is > 0) and " 2134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 1)) and " 2135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 2) and " 2136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 3))", 2137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7)); 2141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((is >= 0) and " 2142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is < 10)) and " 2143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 3) and " 2144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 5) and " 2145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 7)))", 2146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that AllOf(m1, ..., mn) describes its negation properly. 2150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllOfTest, CanDescribeNegation) { 2151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Le(2), Ge(1)); 2153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(isn't <= 2) or " 2154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't >= 1)", 2155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2)); 2158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(isn't > 0) or " 2159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 1) or " 2160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 2))", 2161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3)); 2165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((isn't > 0) or " 2166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 1)) or " 2167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 2) or " 2168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 3))", 2169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7)); 2173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((isn't >= 0) or " 2174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't < 10)) or " 2175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 3) or " 2176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 5) or " 2177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 7)))", 2178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that monomorphic matchers are safely cast by the AllOf matcher. 2182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) { 2183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // greater_than_5 and less_than_10 are monomorphic matchers. 2184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> greater_than_5 = Gt(5); 2185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> less_than_10 = Lt(10); 2186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m = AllOf(greater_than_5, less_than_10); 2188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = AllOf(greater_than_5, less_than_10); 2189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m3 = AllOf(greater_than_5, m2); 2190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests that BothOf works when composing itself. 2192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10); 2193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10); 2194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllOfTest, ExplainsResult) { 2197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. Both matchers need to explain. The second 2200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher doesn't give an explanation, so only the first matcher's 2201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explanation is printed. 2202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), Lt(30)); 2203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 15 more than 10", Explain(m, 25)); 2204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. Both matchers need to explain. 2206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20)); 2207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20", 2208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, 30)); 2209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. All matchers need to explain. The second 2211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher doesn't given an explanation. 2212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20)); 2213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20", 2214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, 25)); 2215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. All matchers need to explain. 2217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30)); 2218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, " 2219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and which is 10 more than 30", 2220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, 40)); 2221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. The first matcher, which failed, needs to 2223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain. 2224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20)); 2225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 less than 10", Explain(m, 5)); 2226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. The second matcher, which failed, needs to 2228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain. Since it doesn't given an explanation, nothing is 2229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // printed. 2230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), Lt(30)); 2231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, 40)); 2232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. The second matcher, which failed, needs to 2234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain. 2235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20)); 2236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 less than 20", Explain(m, 15)); 2237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Helper to allow easy testing of AnyOf matchers with num parameters. 2240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid AnyOfMatches(int num, const Matcher<int>& m) { 2241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SCOPED_TRACE(Describe(m)); 2242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (int i = 1; i <= num; ++i) { 2244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(i)); 2245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(num + 1)); 2247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that AnyOf(m1, ..., mn) matches any value that matches at 2250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// least one of the given matchers. 2251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnyOfTest, MatchesWhenAnyMatches) { 2252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Le(1), Ge(3)); 2254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(1)); 2255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(4)); 2256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(2)); 2257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2)); 2259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(-1)); 2260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(1)); 2261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(2)); 2262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3)); 2265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(-1)); 2266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(1)); 2267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(2)); 2268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(3)); 2269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Le(0), Gt(10), 3, 5, 7); 2272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(0)); 2273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(11)); 2274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(3)); 2275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(2)); 2276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The following tests for varying number of sub-matchers. Due to the way 2278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the sub-matchers are handled it is enough to test every sub-matcher once 2279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // with sub-matchers using the same matcher type. Varying matcher types are 2280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // checked for above. 2281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(2, AnyOf(1, 2)); 2282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(3, AnyOf(1, 2, 3)); 2283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(4, AnyOf(1, 2, 3, 4)); 2284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5)); 2285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6)); 2286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7)); 2287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8)); 2288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9)); 2289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); 2290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_LANG_CXX11 2293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests the variadic version of the AnyOfMatcher. 2294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnyOfTest, VariadicMatchesWhenAnyMatches) { 2295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Also make sure AnyOf is defined in the right namespace and does not depend 2296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // on ADL. 2297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); 2298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Describe(m), EndsWith("or (is equal to 11))))))))))")); 2300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(11, m); 2301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 2303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 2304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 2305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 41, 42, 43, 44, 45, 46, 47, 48, 49, 50)); 2306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_LANG_CXX11 2309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that AnyOf(m1, ..., mn) describes itself properly. 2311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnyOfTest, CanDescribeSelf) { 2312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Le(1), Ge(3)); 2314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(is <= 1) or (is >= 3)", 2315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2)); 2318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(is < 0) or " 2319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 1) or (is equal to 2))", 2320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3)); 2323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((is < 0) or " 2324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 1)) or " 2325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 2) or " 2326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 3))", 2327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Le(0), Gt(10), 3, 5, 7); 2330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((is <= 0) or " 2331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is > 10)) or " 2332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 3) or " 2333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((is equal to 5) or " 2334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(is equal to 7)))", 2335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that AnyOf(m1, ..., mn) describes its negation properly. 2339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnyOfTest, CanDescribeNegation) { 2340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Le(1), Ge(3)); 2342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(isn't <= 1) and (isn't >= 3)", 2343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2)); 2346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(isn't < 0) and " 2347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 1) and (isn't equal to 2))", 2348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3)); 2351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((isn't < 0) and " 2352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 1)) and " 2353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 2) and " 2354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 3))", 2355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(Le(0), Gt(10), 3, 5, 7); 2358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("((isn't <= 0) and " 2359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't > 10)) and " 2360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 3) and " 2361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "((isn't equal to 5) and " 2362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "(isn't equal to 7)))", 2363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 2364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that monomorphic matchers are safely cast by the AnyOf matcher. 2367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) { 2368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // greater_than_5 and less_than_10 are monomorphic matchers. 2369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> greater_than_5 = Gt(5); 2370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> less_than_10 = Lt(10); 2371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m = AnyOf(greater_than_5, less_than_10); 2373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10); 2374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m3 = AnyOf(greater_than_5, m2); 2375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests that EitherOf works when composing itself. 2377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10); 2378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10); 2379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AnyOfTest, ExplainsResult) { 2382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m; 2383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. Both matchers need to explain. The second 2385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher doesn't give an explanation, so only the first matcher's 2386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explanation is printed. 2387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(10), Lt(0)); 2388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 less than 10", Explain(m, 5)); 2389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. Both matchers need to explain. 2391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(10), GreaterThan(20)); 2392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20", 2393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, 5)); 2394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. All matchers need to explain. The second 2396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher doesn't given an explanation. 2397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30)); 2398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30", 2399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, 5)); 2400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed match. All matchers need to explain. 2402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30)); 2403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, " 2404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and which is 25 less than 30", 2405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, 5)); 2406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. The first matcher, which succeeded, needs to 2408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain. 2409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(10), GreaterThan(20)); 2410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 more than 10", Explain(m, 15)); 2411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. The second matcher, which succeeded, needs to 2413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain. Since it doesn't given an explanation, nothing is 2414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // printed. 2415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(10), Lt(30)); 2416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, 0)); 2417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Successful match. The second matcher, which succeeded, needs to 2419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explain. 2420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = AnyOf(GreaterThan(30), GreaterThan(20)); 2421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 5 more than 20", Explain(m, 25)); 2422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The following predicate function and predicate functor are for 2425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// testing the Truly(predicate) matcher. 2426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns non-zero if the input is positive. Note that the return 2428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type of this function is not bool. It's OK as Truly() accepts any 2429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// unary function or functor whose return type can be implicitly 2430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// converted to bool. 2431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochint IsPositive(double x) { 2432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return x > 0 ? 1 : 0; 2433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This functor returns true if the input is greater than the given 2436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// number. 2437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass IsGreaterThan { 2438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit IsGreaterThan(int threshold) : threshold_(threshold) {} 2440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator()(int n) const { return n > threshold_; } 2442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int threshold_; 2445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For testing Truly(). 2448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst int foo = 0; 2449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// This predicate returns true iff the argument references foo and has 2451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a zero value. 2452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool ReferencesFooAndIsZero(const int& n) { 2453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (&n == &foo) && (n == 0); 2454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Truly(predicate) matches what satisfies the given 2457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// predicate. 2458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TrulyTest, MatchesWhatSatisfiesThePredicate) { 2459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m = Truly(IsPositive); 2460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(2.0)); 2461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(-1.5)); 2462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Truly(predicate_functor) works too. 2465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TrulyTest, CanBeUsedWithFunctor) { 2466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Truly(IsGreaterThan(5)); 2467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(6)); 2468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(4)); 2469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A class that can be implicitly converted to bool. 2472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ConvertibleToBool { 2473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ConvertibleToBool(int number) : number_(number) {} 2475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch operator bool() const { return number_ != 0; } 2476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int number_; 2479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochConvertibleToBool IsNotZero(int number) { 2482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ConvertibleToBool(number); 2483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that the predicate used in Truly() may return a class that's 2486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// implicitly convertible to bool, even when the class has no 2487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// operator!(). 2488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) { 2489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> m = Truly(IsNotZero); 2490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(1)); 2491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(0)); 2492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Truly(predicate) can describe itself properly. 2495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TrulyTest, CanDescribeSelf) { 2496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m = Truly(IsPositive); 2497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("satisfies the given predicate", 2498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 2499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Truly(predicate) works when the matcher takes its 2502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// argument by reference. 2503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(TrulyTest, WorksForByRefArguments) { 2504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> m = Truly(ReferencesFooAndIsZero); 2505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(foo)); 2506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 2507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(n)); 2508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Matches(m) is a predicate satisfied by whatever that 2511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches matcher m. 2512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) { 2513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(Matches(Ge(0))(1)); 2514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(Matches(Eq('a'))('b')); 2515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Matches(m) works when the matcher takes its argument by 2518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// reference. 2519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchesTest, WorksOnByRefArguments) { 2520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int m = 0, n = 0; 2521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n)); 2522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(Matches(Ref(m))(n)); 2523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that a Matcher on non-reference type can be used in 2526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches(). 2527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatchesTest, WorksWithMatcherOnNonRefType) { 2528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> eq5 = Eq(5); 2529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(Matches(eq5)(5)); 2530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(Matches(eq5)(2)); 2531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests Value(value, matcher). Since Value() is a simple wrapper for 2534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Matches(), which has been tested already, we don't spend a lot of 2535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// effort on testing Value(). 2536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ValueTest, WorksWithPolymorphicMatcher) { 2537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(Value("hi", StartsWith("h"))); 2538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(Value(5, Gt(10))); 2539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ValueTest, WorksWithMonomorphicMatcher) { 2542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> is_zero = Eq(0); 2543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(Value(0, is_zero)); 2544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(Value('a', is_zero)); 2545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 0; 2547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const int&> ref_n = Ref(n); 2548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(Value(n, ref_n)); 2549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(Value(1, ref_n)); 2550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) { 2553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener1; 2554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1)); 2555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("% 2 == 0", listener1.str()); 2556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener2; 2558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2)); 2559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", listener2.str()); 2560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) { 2563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> is_even = PolymorphicIsEven(); 2564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener1; 2565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1)); 2566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("% 2 == 0", listener1.str()); 2567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const double&> is_zero = Eq(0); 2569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener2; 2570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2)); 2571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", listener2.str()); 2572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMATCHER_P(Really, inner_matcher, "") { 2575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ExplainMatchResult(inner_matcher, arg, result_listener); 2576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, WorksInsideMATCHER) { 2579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(0, Really(Eq(0))); 2580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllArgsTest, WorksForTuple) { 2583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt())); 2584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt()))); 2585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllArgsTest, WorksForNonTuple) { 2588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(42, AllArgs(Gt(0))); 2589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT('a', Not(AllArgs(Eq('b')))); 2590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass AllArgsHelper { 2593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 2594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllArgsHelper() {} 2595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MOCK_METHOD2(Helper, int(char x, int y)); 2597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 2599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper); 2600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(AllArgsTest, WorksInWithClause) { 2603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AllArgsHelper helper; 2604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ON_CALL(helper, Helper(_, _)) 2605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch .With(AllArgs(Lt())) 2606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch .WillByDefault(Return(1)); 2607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_CALL(helper, Helper(_, _)); 2608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_CALL(helper, Helper(_, _)) 2609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch .With(AllArgs(Gt())) 2610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch .WillOnce(Return(2)); 2611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(1, helper.Helper('\1', 2)); 2613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(2, helper.Helper('a', 1)); 2614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value 2617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// matches the matcher. 2618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) { 2619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ASSERT_THAT(5, Ge(2)) << "This should succeed."; 2620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ASSERT_THAT("Foo", EndsWith("oo")); 2621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too."; 2622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT("Hello", StartsWith("Hell")); 2623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value 2626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// doesn't match the matcher. 2627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) { 2628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(), 2629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // which cannot reference auto variables. 2630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static unsigned short n; // NOLINT 2631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = 5; 2632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // VC++ prior to version 8.0 SP1 has a bug where it will not see any 2634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // functions declared in the namespace scope from within nested classes. 2635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all 2636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // namespace-level functions invoked inside them need to be explicitly 2637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // resolved. 2638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)), 2639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Value of: n\n" 2640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: is > 10\n" 2641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: 5" + OfType("unsigned short")); 2642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = 0; 2643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_NONFATAL_FAILURE( 2644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))), 2645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Value of: n\n" 2646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: (is <= 7) and (is >= 5)\n" 2647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: 0" + OfType("unsigned short")); 2648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument 2651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// has a reference type. 2652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherAssertionTest, WorksForByRefArguments) { 2653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We use a static variable here as EXPECT_FATAL_FAILURE() cannot 2654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // reference auto variables. 2655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static int n; 2656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = 0; 2657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(n, AllOf(Le(7), Ref(n))); 2658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))), 2659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Value of: n\n" 2660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: does not reference the variable @"); 2661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests the "Actual" part. 2662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))), 2663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Actual: 0" + OfType("int") + ", which is located @"); 2664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if !GTEST_OS_SYMBIAN 2667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is 2668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// monomorphic. 2669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's 2671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Symbian compiler: it tries to compile 2672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// template<T, U> class MatcherCastImpl { ... 2673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// virtual bool MatchAndExplain(T x, ...) const { 2674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// return source_matcher_.MatchAndExplain(static_cast<U>(x), ...); 2675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// with U == string and T == const char* 2676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... ) 2677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the compiler silently crashes with no output. 2678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x) 2679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// the code compiles but the converted string is bogus. 2680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherAssertionTest, WorksForMonomorphicMatcher) { 2681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> starts_with_he = StartsWith("he"); 2682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ASSERT_THAT("hello", starts_with_he); 2683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> ends_with_ok = EndsWith("ok"); 2685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ASSERT_THAT("book", ends_with_ok); 2686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string bad = "bad"; 2687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad, ends_with_ok), 2688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Value of: bad\n" 2689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: ends with \"ok\"\n" 2690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: \"bad\""); 2691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> is_greater_than_5 = Gt(5); 2692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5), 2693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Value of: 5\n" 2694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "Expected: is > 5\n" 2695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: 5" + OfType("int")); 2696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // !GTEST_OS_SYMBIAN 2698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests floating-point matchers. 2700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename RawType> 2701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass FloatingPointTest : public testing::Test { 2702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 2703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef testing::internal::FloatingPoint<RawType> Floating; 2704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename Floating::Bits Bits; 2705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FloatingPointTest() 2707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : max_ulps_(Floating::kMaxUlps), 2708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch zero_bits_(Floating(0).bits()), 2709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch one_bits_(Floating(1).bits()), 2710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch infinity_bits_(Floating(Floating::Infinity()).bits()), 2711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch close_to_positive_zero_( 2712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Floating::ReinterpretBits(zero_bits_ + max_ulps_/2)), 2713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch close_to_negative_zero_( 2714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch -Floating::ReinterpretBits(zero_bits_ + max_ulps_ - max_ulps_/2)), 2715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch further_from_negative_zero_(-Floating::ReinterpretBits( 2716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch zero_bits_ + max_ulps_ + 1 - max_ulps_/2)), 2717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch close_to_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_)), 2718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch further_from_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_ + 1)), 2719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch infinity_(Floating::Infinity()), 2720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch close_to_infinity_( 2721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Floating::ReinterpretBits(infinity_bits_ - max_ulps_)), 2722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch further_from_infinity_( 2723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Floating::ReinterpretBits(infinity_bits_ - max_ulps_ - 1)), 2724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch max_(Floating::Max()), 2725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch nan1_(Floating::ReinterpretBits(Floating::kExponentBitMask | 1)), 2726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch nan2_(Floating::ReinterpretBits(Floating::kExponentBitMask | 200)) { 2727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void TestSize() { 2730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 2731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A battery of tests for FloatingEqMatcher::Matches. 2734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_maker is a pointer to a function which creates a FloatingEqMatcher. 2735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void TestMatches( 2736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) { 2737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m1 = matcher_maker(0.0); 2738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(-0.0)); 2739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(close_to_positive_zero_)); 2740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(close_to_negative_zero_)); 2741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(1.0)); 2742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_); 2744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(further_from_negative_zero_)); 2745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m3 = matcher_maker(1.0); 2747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(close_to_one_)); 2748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(further_from_one_)); 2749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above. 2751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(0.0)); 2752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m4 = matcher_maker(-infinity_); 2754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m4.Matches(-close_to_infinity_)); 2755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m5 = matcher_maker(infinity_); 2757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m5.Matches(close_to_infinity_)); 2758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This is interesting as the representations of infinity_ and nan1_ 2760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // are only 1 DLP apart. 2761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m5.Matches(nan1_)); 2762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_maker can produce a Matcher<const RawType&>, which is needed in 2764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // some cases. 2765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const RawType&> m6 = matcher_maker(0.0); 2766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m6.Matches(-0.0)); 2767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m6.Matches(close_to_positive_zero_)); 2768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m6.Matches(1.0)); 2769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_maker can produce a Matcher<RawType&>, which is needed in some 2771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // cases. 2772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType&> m7 = matcher_maker(0.0); 2773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RawType x = 0.0; 2774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m7.Matches(x)); 2775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = 0.01f; 2776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m7.Matches(x)); 2777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Pre-calculated numbers to be used by the tests. 2780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const size_t max_ulps_; 2782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits zero_bits_; // The bits that represent 0.0. 2784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits one_bits_; // The bits that represent 1.0. 2785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Bits infinity_bits_; // The bits that represent +infinity. 2786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Some numbers close to 0.0. 2788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType close_to_positive_zero_; 2789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType close_to_negative_zero_; 2790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType further_from_negative_zero_; 2791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Some numbers close to 1.0. 2793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType close_to_one_; 2794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType further_from_one_; 2795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Some numbers close to +infinity. 2797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType infinity_; 2798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType close_to_infinity_; 2799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType further_from_infinity_; 2800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Maximum representable value that's not infinity. 2802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType max_; 2803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Some NaNs. 2805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType nan1_; 2806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const RawType nan2_; 2807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests floating-point matchers with fixed epsilons. 2810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename RawType> 2811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass FloatingPointNearTest : public FloatingPointTest<RawType> { 2812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 2813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef FloatingPointTest<RawType> ParentType; 2814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon. 2816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_maker is a pointer to a function which creates a FloatingEqMatcher. 2817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void TestNearMatches( 2818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::internal::FloatingEqMatcher<RawType> 2819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch (*matcher_maker)(RawType, RawType)) { 2820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m1 = matcher_maker(0.0, 0.0); 2821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(0.0)); 2822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m1.Matches(-0.0)); 2823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(ParentType::close_to_positive_zero_)); 2824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(ParentType::close_to_negative_zero_)); 2825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m1.Matches(1.0)); 2826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m2 = matcher_maker(0.0, 1.0); 2828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(0.0)); 2829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(-0.0)); 2830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(1.0)); 2831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m2.Matches(-1.0)); 2832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(ParentType::close_to_one_)); 2833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m2.Matches(-ParentType::close_to_one_)); 2834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Check that inf matches inf, regardless of the of the specified max 2836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // absolute error. 2837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0); 2838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m3.Matches(ParentType::infinity_)); 2839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(ParentType::close_to_infinity_)); 2840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m3.Matches(-ParentType::infinity_)); 2841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0); 2843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m4.Matches(-ParentType::infinity_)); 2844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m4.Matches(-ParentType::close_to_infinity_)); 2845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m4.Matches(ParentType::infinity_)); 2846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Test various overflow scenarios. 2848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_); 2849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m5.Matches(ParentType::max_)); 2850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m5.Matches(-ParentType::max_)); 2851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_); 2853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m6.Matches(ParentType::max_)); 2854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m6.Matches(-ParentType::max_)); 2855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0); 2857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m7.Matches(ParentType::max_)); 2858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m7.Matches(-ParentType::max_)); 2859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0); 2861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m8.Matches(ParentType::max_)); 2862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m8.Matches(-ParentType::max_)); 2863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The difference between max() and -max() normally overflows to infinity, 2865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // but it should still match if the max_abs_error is also infinity. 2866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType> m9 = matcher_maker( 2867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ParentType::max_, ParentType::infinity_); 2868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m8.Matches(-ParentType::max_)); 2869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_maker can produce a Matcher<const RawType&>, which is needed in 2871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // some cases. 2872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0); 2873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m10.Matches(-0.0)); 2874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m10.Matches(ParentType::close_to_positive_zero_)); 2875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m10.Matches(ParentType::close_to_one_)); 2876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // matcher_maker can produce a Matcher<RawType&>, which is needed in some 2878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // cases. 2879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<RawType&> m11 = matcher_maker(0.0, 1.0); 2880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RawType x = 0.0; 2881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m11.Matches(x)); 2882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = 1.0f; 2883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m11.Matches(x)); 2884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = -1.0f; 2885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m11.Matches(x)); 2886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = 1.1f; 2887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m11.Matches(x)); 2888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = -1.1f; 2889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m11.Matches(x)); 2890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 2891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 2892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Instantiate FloatingPointTest for testing floats. 2894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef FloatingPointTest<float> FloatTest; 2895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) { 2897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestMatches(&FloatEq); 2898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) { 2901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestMatches(&NanSensitiveFloatEq); 2902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatTest, FloatEqCannotMatchNaN) { 2905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // FloatEq never matches NaN. 2906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m = FloatEq(nan1_); 2907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan1_)); 2908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan2_)); 2909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) { 2913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NanSensitiveFloatEq will match NaN. 2914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m = NanSensitiveFloatEq(nan1_); 2915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan1_)); 2916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan2_)); 2917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatTest, FloatEqCanDescribeSelf) { 2921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m1 = FloatEq(2.0f); 2922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 2923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 2924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m2 = FloatEq(0.5f); 2926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 2927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 2928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m3 = FloatEq(nan1_); 2930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("never matches", Describe(m3)); 2931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", DescribeNegation(m3)); 2932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) { 2935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m1 = NanSensitiveFloatEq(2.0f); 2936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 2937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 2938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m2 = NanSensitiveFloatEq(0.5f); 2940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 2941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 2942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m3 = NanSensitiveFloatEq(nan1_); 2944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is NaN", Describe(m3)); 2945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't NaN", DescribeNegation(m3)); 2946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Instantiate FloatingPointTest for testing floats with a user-specified 2949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// max absolute error. 2950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef FloatingPointNearTest<float> FloatNearTest; 2951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatNearTest, FloatNearMatches) { 2953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestNearMatches(&FloatNear); 2954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats) { 2957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestNearMatches(&NanSensitiveFloatNear); 2958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatNearTest, FloatNearCanDescribeSelf) { 2961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m1 = FloatNear(2.0f, 0.5f); 2962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1)); 2963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 2964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1)); 2965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m2 = FloatNear(0.5f, 0.5f); 2967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2)); 2968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 2969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2)); 2970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m3 = FloatNear(nan1_, 0.0); 2972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("never matches", Describe(m3)); 2973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", DescribeNegation(m3)); 2974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) { 2977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f); 2978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1)); 2979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 2980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1)); 2981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f); 2983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2)); 2984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 2985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2)); 2986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f); 2988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is NaN", Describe(m3)); 2989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't NaN", DescribeNegation(m3)); 2990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 2992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatNearTest, FloatNearCannotMatchNaN) { 2993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // FloatNear never matches NaN. 2994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f); 2995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan1_)); 2996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan2_)); 2997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 2999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) { 3001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NanSensitiveFloatNear will match NaN. 3002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f); 3003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan1_)); 3004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan2_)); 3005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 3006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Instantiate FloatingPointTest for testing doubles. 3009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef FloatingPointTest<double> DoubleTest; 3010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) { 3012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestMatches(&DoubleEq); 3013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) { 3016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestMatches(&NanSensitiveDoubleEq); 3017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleTest, DoubleEqCannotMatchNaN) { 3020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // DoubleEq never matches NaN. 3021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m = DoubleEq(nan1_); 3022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan1_)); 3023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan2_)); 3024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 3025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) { 3028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NanSensitiveDoubleEq will match NaN. 3029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m = NanSensitiveDoubleEq(nan1_); 3030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan1_)); 3031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan2_)); 3032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 3033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleTest, DoubleEqCanDescribeSelf) { 3036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = DoubleEq(2.0); 3037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 3038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 3039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m2 = DoubleEq(0.5); 3041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 3042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 3043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m3 = DoubleEq(nan1_); 3045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("never matches", Describe(m3)); 3046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", DescribeNegation(m3)); 3047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) { 3050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = NanSensitiveDoubleEq(2.0); 3051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 3052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 3053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m2 = NanSensitiveDoubleEq(0.5); 3055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 3056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 3057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m3 = NanSensitiveDoubleEq(nan1_); 3059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is NaN", Describe(m3)); 3060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't NaN", DescribeNegation(m3)); 3061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Instantiate FloatingPointTest for testing floats with a user-specified 3064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// max absolute error. 3065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef FloatingPointNearTest<double> DoubleNearTest; 3066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, DoubleNearMatches) { 3068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestNearMatches(&DoubleNear); 3069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles) { 3072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TestNearMatches(&NanSensitiveDoubleNear); 3073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) { 3076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = DoubleNear(2.0, 0.5); 3077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1)); 3078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1)); 3080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m2 = DoubleNear(0.5, 0.5); 3082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2)); 3083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2)); 3085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m3 = DoubleNear(nan1_, 0.0); 3087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("never matches", Describe(m3)); 3088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is anything", DescribeNegation(m3)); 3089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) { 3092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05)); 3093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2)); 3094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7)); 3095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string explanation = Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10); 3097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Different C++ implementations may print floating-point numbers 3098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // slightly differently. 3099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" || // GCC 3100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explanation == "which is 1.2e-010 from 2.1") // MSVC 3101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " where explanation is \"" << explanation << "\"."; 3102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) { 3105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5); 3106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1)); 3107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1)); 3109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5); 3111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2)); 3112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2)); 3114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1); 3116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is NaN", Describe(m3)); 3117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't NaN", DescribeNegation(m3)); 3118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) { 3121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // DoubleNear never matches NaN. 3122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1); 3123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan1_)); 3124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(nan2_)); 3125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 3126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) { 3129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NanSensitiveDoubleNear will match NaN. 3130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1); 3131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan1_)); 3132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(nan2_)); 3133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 3134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, RawPointer) { 3137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int*> m = Pointee(Ge(0)); 3138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 1; 3140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&n)); 3141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = -1; 3142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&n)); 3143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, RawPointerToConst) { 3147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const double*> m = Pointee(Ge(0)); 3148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double x = 1; 3150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&x)); 3151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = -1; 3152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&x)); 3153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, ReferenceToConstRawPointer) { 3157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int* const &> m = Pointee(Ge(0)); 3158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 1; 3160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&n)); 3161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = -1; 3162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&n)); 3163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, ReferenceToNonConstRawPointer) { 3167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<double* &> m = Pointee(Ge(0)); 3168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double x = 1.0; 3170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double* p = &x; 3171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(p)); 3172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch x = -1; 3173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(p)); 3174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch p = NULL; 3175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(p)); 3176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMATCHER_P(FieldIIs, inner_matcher, "") { 3179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ExplainMatchResult(inner_matcher, arg.i, result_listener); 3180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, SameType) { 3183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 3184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch derived.i = 4; 3185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Right type. A pointer is passed down. 3187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base* as_base_ptr = &derived; 3188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull()))); 3189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4)))); 3190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, 3191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5))))); 3192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, WrongTypes) { 3195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base base; 3196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 3197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch OtherDerived other_derived; 3198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Wrong types. NULL is passed. 3200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_)))); 3201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull())); 3202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base* as_base_ptr = &derived; 3203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_)))); 3204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull())); 3205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch as_base_ptr = &other_derived; 3206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_)))); 3207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull())); 3208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, AlreadyNull) { 3211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Already NULL. 3212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base* as_base_ptr = NULL; 3213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull())); 3214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AmbiguousCastTypes { 3217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class VirtualDerived : public virtual Base {}; 3218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class DerivedSub1 : public VirtualDerived {}; 3219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class DerivedSub2 : public VirtualDerived {}; 3220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {}; 3221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, AmbiguousCast) { 3224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AmbiguousCastTypes::DerivedSub1 sub1; 3225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AmbiguousCastTypes::ManyDerivedInHierarchy many_derived; 3226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Multiply derived from Base. dynamic_cast<> returns NULL. 3227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base* as_base_ptr = 3228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived); 3229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ptr, 3230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull())); 3231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch as_base_ptr = &sub1; 3232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 3233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch as_base_ptr, 3234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull()))); 3235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, Describe) { 3238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_)); 3239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_RTTI 3240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string prefix = 3241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", "; 3242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else // GTEST_HAS_RTTI 3243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string prefix = "when dynamic_cast, "; 3244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_RTTI 3245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher)); 3246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(prefix + "does not point to a value that is anything", 3247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(matcher)); 3248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, Explain) { 3251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_)); 3252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base* null = NULL; 3253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL")); 3254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 3255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(&derived)); 3256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to ")); 3257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // With references, the matcher itself can fail. Test for that one. 3259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_); 3260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Explain(ref_matcher, derived), 3261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch HasSubstr("which cannot be dynamic_cast")); 3262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, GoodReference) { 3265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 3266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch derived.i = 4; 3267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base& as_base_ref = derived; 3268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4))); 3269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5)))); 3270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenDynamicCastToTest, BadReference) { 3273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Derived derived; 3274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Base& as_base_ref = derived; 3275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_))); 3276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Minimal const-propagating pointer. 3279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 3280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ConstPropagatingPtr { 3281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef T element_type; 3283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConstPropagatingPtr() : val_() {} 3285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit ConstPropagatingPtr(T* t) : val_(t) {} 3286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConstPropagatingPtr(const ConstPropagatingPtr& other) : val_(other.val_) {} 3287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch T* get() { return val_; } 3289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch T& operator*() { return *val_; } 3290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Most smart pointers return non-const T* and T& from the next methods. 3291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const T* get() const { return val_; } 3292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const T& operator*() const { return *val_; } 3293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch T* val_; 3296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, WorksWithConstPropagatingPointers) { 3299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5)); 3300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int three = 3; 3301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ConstPropagatingPtr<int> co(&three); 3302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConstPropagatingPtr<int> o(&three); 3303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(o)); 3304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(co)); 3305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *o = 6; 3306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(o)); 3307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(ConstPropagatingPtr<int>())); 3308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, NeverMatchesNull) { 3311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const char*> m = Pointee(_); 3312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that we can write Pointee(value) instead of Pointee(Eq(value)). 3316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, MatchesAgainstAValue) { 3317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int*> m = Pointee(5); 3318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 5; 3320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&n)); 3321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = -1; 3322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&n)); 3323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, CanDescribeSelf) { 3327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int*> m = Pointee(Gt(3)); 3328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("points to a value that is > 3", Describe(m)); 3329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("does not point to a value that is > 3", 3330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 3331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, CanExplainMatchResult) { 3334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const string*> m = Pointee(StartsWith("Hi")); 3335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL))); 3337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<long*> m2 = Pointee(GreaterThan(1)); // NOLINT 3339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch long n = 3; // NOLINT 3340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1", 3341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m2, &n)); 3342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointeeTest, AlwaysExplainsPointee) { 3345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int*> m = Pointee(0); 3346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n = 42; 3347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which points to 42" + OfType("int"), Explain(m, &n)); 3348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// An uncopyable class. 3351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Uncopyable { 3352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Uncopyable() : value_(-1) {} 3354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit Uncopyable(int a_value) : value_(a_value) {} 3355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value() const { return value_; } 3357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void set_value(int i) { value_ = i; } 3358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value_; 3361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable); 3362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Returns true iff x.value() is positive. 3365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; } 3366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochMATCHER_P(UncopyableIs, inner_matcher, "") { 3368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ExplainMatchResult(inner_matcher, arg.value(), result_listener); 3369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A user-defined struct for testing Field(). 3372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct AStruct { 3373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct() : x(0), y(1.0), z(5), p(NULL) {} 3374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct(const AStruct& rhs) 3375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {} 3376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int x; // A non-const field. 3378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double y; // A const field. 3379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Uncopyable z; // An uncopyable field. 3380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* p; // A pointer field. 3381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(AStruct); 3384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A derived struct for testing Field(). 3387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct DerivedStruct : public AStruct { 3388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char ch; 3389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_ASSIGN_(DerivedStruct); 3392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, ...) works when field is non-const. 3395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForNonConstField) { 3396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AStruct> m = Field(&AStruct::x, Ge(0)); 3397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = -1; 3401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, ...) works when field is const. 3405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForConstField) { 3406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0)); 3409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Field(&AStruct::y, Le(0.0)); 3411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, ...) works when field is not copyable. 3415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForUncopyableField) { 3416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive)); 3419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Field(&AStruct::z, Not(Truly(ValueIsPositive))); 3421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, ...) works when field is a pointer. 3425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForPointerField) { 3426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matching against NULL. 3427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL)); 3428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.p = "hi"; 3431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Matching a pointer that is not NULL. 3434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Field(&AStruct::p, StartsWith("hi")); 3435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.p = "hill"; 3436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.p = "hole"; 3438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() works when the object is passed by reference. 3442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForByRefArgument) { 3443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0)); 3444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = -1; 3448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, ...) works when the argument's type 3452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is a sub-type of Foo. 3453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForArgumentOfSubType) { 3454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Note that the matcher expects DerivedStruct but we say AStruct 3455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // inside Field(). 3456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0)); 3457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DerivedStruct d; 3459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(d)); 3460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.x = -1; 3461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(d)); 3462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, m) works when field's type and m's 3465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// argument type are compatible but not the same. 3466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, WorksForCompatibleMatcherType) { 3467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The field is an int, but the inner matcher expects a signed char. 3468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, 3469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<signed char>(Ge(0))); 3470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = -1; 3474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() can describe itself. 3478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, CanDescribeSelf) { 3479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0)); 3480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given field is >= 0", Describe(m)); 3482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m)); 3483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() can explain the match result. 3486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldTest, CanExplainMatchResult) { 3487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0)); 3488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = 1; 3491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m, a)); 3492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Field(&AStruct::x, GreaterThan(0)); 3494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "whose given field is 1" + OfType("int") + ", which is 1 more than 0", 3496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, a)); 3497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() works when the argument is a pointer to const. 3500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, WorksForPointerToConst) { 3501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0)); 3502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = -1; 3506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() works when the argument is a pointer to non-const. 3510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, WorksForPointerToNonConst) { 3511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AStruct*> m = Field(&AStruct::x, Ge(0)); 3512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = -1; 3516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() works when the argument is a reference to a const pointer. 3520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, WorksForReferenceToConstPointer) { 3521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0)); 3522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = -1; 3526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() does not match the NULL pointer. 3530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, DoesNotMatchNull) { 3531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, _); 3532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field(&Foo::field, ...) works when the argument's type 3536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// is a sub-type of const Foo*. 3537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, WorksForArgumentOfSubType) { 3538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Note that the matcher expects DerivedStruct but we say AStruct 3539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // inside Field(). 3540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0)); 3541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DerivedStruct d; 3543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&d)); 3544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.x = -1; 3545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&d)); 3546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() can describe itself when used to match a pointer. 3549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, CanDescribeSelf) { 3550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0)); 3551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given field is >= 0", Describe(m)); 3553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m)); 3554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Field() can explain the result of matching a pointer. 3557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FieldForPointerTest, CanExplainMatchResult) { 3558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0)); 3559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AStruct a; 3561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.x = 1; 3562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL))); 3563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"), 3564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, &a)); 3565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Field(&AStruct::x, GreaterThan(0)); 3567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") + 3568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ", which is 1 more than 0", Explain(m, &a)); 3569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A user-defined class for testing Property(). 3572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass AClass { 3573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass() : n_(0) {} 3575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A getter that returns a non-reference. 3577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n() const { return n_; } 3578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void set_n(int new_n) { n_ = new_n; } 3580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A getter that returns a reference to const. 3582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string& s() const { return s_; } 3583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void set_s(const string& new_s) { s_ = new_s; } 3585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A getter that returns a reference to non-const. 3587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double& x() const { return x_; } 3588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int n_; 3590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string s_; 3591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static double x_; 3593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochdouble AClass::x_ = 0.0; 3596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// A derived class for testing Property(). 3598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass DerivedClass : public AClass { 3599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int k() const { return k_; } 3601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int k_; 3603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, ...) works when property() 3606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns a non-reference. 3607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, WorksForNonReferenceProperty) { 3608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, Ge(0)); 3609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(1); 3612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(-1); 3615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, ...) works when property() 3619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns a reference to const. 3620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, WorksForReferenceToConstProperty) { 3621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi")); 3622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hill"); 3625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hole"); 3628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, ...) works when property() 3632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns a reference to non-const. 3633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, WorksForReferenceToNonConstProperty) { 3634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double x = 0.0; 3635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass&> m = Property(&AClass::x, Ref(x)); 3638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Property(&AClass::x, Not(Ref(x))); 3641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, ...) works when the argument is 3645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// passed by value. 3646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, WorksForByValueArgument) { 3647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AClass> m = Property(&AClass::s, StartsWith("hi")); 3648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hill"); 3651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hole"); 3654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, ...) works when the argument's 3658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type is a sub-type of Foo. 3659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, WorksForArgumentOfSubType) { 3660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The matcher expects a DerivedClass, but inside the Property() we 3661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // say AClass. 3662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0)); 3663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DerivedClass d; 3665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.set_n(1); 3666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(d)); 3667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.set_n(-1); 3669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(d)); 3670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, m) works when property()'s type 3673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// and m's argument type are compatible but different. 3674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, WorksForCompatibleMatcherType) { 3675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // n() returns an int but the inner matcher expects a signed char. 3676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, 3677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<signed char>(Ge(0))); 3678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(a)); 3681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(-1); 3682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(a)); 3683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() can describe itself. 3686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, CanDescribeSelf) { 3687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, Ge(0)); 3688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given property is >= 0", Describe(m)); 3690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given property isn't >= 0", 3691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 3692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() can explain the match result. 3695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyTest, CanExplainMatchResult) { 3696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, Ge(0)); 3697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(1); 3700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m, a)); 3701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Property(&AClass::n, GreaterThan(0)); 3703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "whose given property is 1" + OfType("int") + ", which is 1 more than 0", 3705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, a)); 3706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() works when the argument is a pointer to const. 3709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, WorksForPointerToConst) { 3710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass*> m = Property(&AClass::n, Ge(0)); 3711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(1); 3714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(-1); 3717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() works when the argument is a pointer to non-const. 3721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, WorksForPointerToNonConst) { 3722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi")); 3723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hill"); 3726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hole"); 3729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() works when the argument is a reference to a 3733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// const pointer. 3734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, WorksForReferenceToConstPointer) { 3735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi")); 3736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hill"); 3739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_s("hole"); 3742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() does not match the NULL pointer. 3746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) { 3747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass*> m = Property(&AClass::x, _); 3748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property(&Foo::property, ...) works when the argument's 3752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// type is a sub-type of const Foo*. 3753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, WorksForArgumentOfSubType) { 3754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The matcher expects a DerivedClass, but inside the Property() we 3755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // say AClass. 3756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0)); 3757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DerivedClass d; 3759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.set_n(1); 3760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(&d)); 3761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.set_n(-1); 3763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(&d)); 3764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() can describe itself when used to match a pointer. 3767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, CanDescribeSelf) { 3768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass*> m = Property(&AClass::n, Ge(0)); 3769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given property is >= 0", Describe(m)); 3771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is an object whose given property isn't >= 0", 3772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 3773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that Property() can explain the result of matching a pointer. 3776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PropertyForPointerTest, CanExplainMatchResult) { 3777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const AClass*> m = Property(&AClass::n, Ge(0)); 3778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AClass a; 3780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.set_n(1); 3781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL))); 3782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 3783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "which points to an object whose given property is 1" + OfType("int"), 3784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, &a)); 3785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Property(&AClass::n, GreaterThan(0)); 3787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which points to an object whose given property is 1" + 3788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch OfType("int") + ", which is 1 more than 0", 3789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, &a)); 3790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests ResultOf. 3793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// function pointer. 3796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstring IntToStringFunction(int input) { return input == 1 ? "foo" : "bar"; } 3797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForFunctionPointers) { 3799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo"))); 3800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(1)); 3802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(2)); 3803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf() can describe itself. 3806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, CanDescribeItself) { 3807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo")); 3808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is mapped by the given callable to a value that " 3810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "is equal to \"foo\"", Describe(matcher)); 3811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is mapped by the given callable to a value that " 3812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "isn't equal to \"foo\"", DescribeNegation(matcher)); 3813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf() can explain the match result. 3816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochint IntFunction(int input) { return input == 42 ? 80 : 90; } 3817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, CanExplainMatchResult) { 3819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(&IntFunction, Ge(85)); 3820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"), 3821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(matcher, 36)); 3822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matcher = ResultOf(&IntFunction, GreaterThan(85)); 3824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") + 3825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ", which is 5 more than 85", Explain(matcher, 36)); 3826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f(x) 3829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns a non-reference. 3830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForNonReferenceResults) { 3831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(&IntFunction, Eq(80)); 3832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(42)); 3834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(36)); 3835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f(x) 3838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns a reference to non-const. 3839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochdouble& DoubleFunction(double& input) { return input; } // NOLINT 3840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochUncopyable& RefUncopyableFunction(Uncopyable& obj) { // NOLINT 3842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return obj; 3843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForReferenceToNonConstResults) { 3846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double x = 3.14; 3847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch double x2 = x; 3848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x)); 3849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(x)); 3851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(x2)); 3852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Test that ResultOf works with uncopyable objects 3854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Uncopyable obj(0); 3855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Uncopyable obj2(0); 3856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<Uncopyable&> matcher2 = 3857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ResultOf(&RefUncopyableFunction, Ref(obj)); 3858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher2.Matches(obj)); 3860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher2.Matches(obj2)); 3861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f(x) 3864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// returns a reference to const. 3865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst string& StringFunction(const string& input) { return input; } 3866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForReferenceToConstResults) { 3868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string s = "foo"; 3869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string s2 = s; 3870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s)); 3871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(s)); 3873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(s2)); 3874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, m) works when f(x) and m's 3877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// argument types are compatible but different. 3878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForCompatibleMatcherTypes) { 3879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // IntFunction() returns int but the inner matcher expects a signed char. 3880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85))); 3881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(36)); 3883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(42)); 3884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that the program aborts when ResultOf is passed 3887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// a NULL function pointer. 3888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfDeathTest, DiesOnNullFunctionPointers) { 3889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_DEATH_IF_SUPPORTED( 3890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ResultOf(static_cast<string(*)(int dummy)>(NULL), Eq(string("foo"))), 3891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "NULL function pointer is passed into ResultOf\\(\\)\\."); 3892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// function reference. 3896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForFunctionReferences) { 3897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo")); 3898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(1)); 3899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(2)); 3900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// function object. 3904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct Functor : public ::std::unary_function<int, string> { 3905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch result_type operator()(argument_type input) const { 3906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return IntToStringFunction(input); 3907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForFunctors) { 3911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo"))); 3912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher.Matches(1)); 3914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher.Matches(2)); 3915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// functor with more then one operator() defined. ResultOf() must work 3919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// for each defined operator(). 3920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct PolymorphicFunctor { 3921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef int result_type; 3922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int operator()(int n) { return n; } 3923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int operator()(const char* s) { return static_cast<int>(strlen(s)); } 3924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForPolymorphicFunctors) { 3927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5)); 3928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher_int.Matches(10)); 3930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher_int.Matches(2)); 3931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5)); 3933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher_string.Matches("long string")); 3935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher_string.Matches("shrt")); 3936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst int* ReferencingFunction(const int& n) { return &n; } 3939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstruct ReferencingFunctor { 3941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef const int* result_type; 3942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch result_type operator()(const int& n) { return &n; } 3943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ResultOfTest, WorksForReferencingCallables) { 3946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int n = 1; 3947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int n2 = 1; 3948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n)); 3949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher2.Matches(n)); 3950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher2.Matches(n2)); 3951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n)); 3953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(matcher3.Matches(n)); 3954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(matcher3.Matches(n2)); 3955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass DivisibleByImpl { 3958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 3959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {} 3960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // For testing using ExplainMatchResultTo() with polymorphic matchers. 3962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T> 3963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const T& n, MatchResultListener* listener) const { 3964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "which is " << (n % divider_) << " modulo " 3965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << divider_; 3966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return (n % divider_) == 0; 3967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(ostream* os) const { 3970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is divisible by " << divider_; 3971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(ostream* os) const { 3974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "is not divisible by " << divider_; 3975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 3976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void set_divider(int a_divider) { divider_ = a_divider; } 3978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int divider() const { return divider_; } 3979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 3981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int divider_; 3982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 3983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochPolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) { 3985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(DivisibleByImpl(n)); 3986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that when AllOf() fails, only the first failing matcher is 3989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// asked to explain why. 3990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, AllOf_False_False) { 3991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3)); 3992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 1 modulo 4", Explain(m, 5)); 3993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 3994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 3995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that when AllOf() fails, only the first failing matcher is 3996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// asked to explain why. 3997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, AllOf_False_True) { 3998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3)); 3999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 2 modulo 4", Explain(m, 6)); 4000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that when AllOf() fails, only the first failing matcher is 4003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// asked to explain why. 4004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, AllOf_True_False) { 4005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3)); 4006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 2 modulo 3", Explain(m, 5)); 4007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that when AllOf() succeeds, all matchers are asked to explain 4010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// why. 4011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, AllOf_True_True) { 4012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3)); 4013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6)); 4014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainMatchResultTest, AllOf_True_True_2) { 4017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m = AllOf(Ge(2), Le(3)); 4018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, 2)); 4019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ExplainmatcherResultTest, MonomorphicMatcher) { 4022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<int> m = GreaterThan(5); 4023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is 1 more than 5", Explain(m, 6)); 4024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The following two tests verify that values without a public copy 4027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// ctor can be used as arguments to matchers like Eq(), Ge(), and etc 4028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// with the help of ByRef(). 4029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass NotCopyable { 4031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 4032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit NotCopyable(int a_value) : value_(a_value) {} 4033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value() const { return value_; } 4035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator==(const NotCopyable& rhs) const { 4037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return value() == rhs.value(); 4038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool operator>=(const NotCopyable& rhs) const { 4041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return value() >= rhs.value(); 4042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 4044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int value_; 4045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable); 4047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 4048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) { 4050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const NotCopyable const_value1(1); 4051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1)); 4052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const NotCopyable n1(1), n2(2); 4054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(n1)); 4055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(n2)); 4056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ByRefTest, AllowsNotCopyableValueInMatchers) { 4059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch NotCopyable value2(2); 4060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<NotCopyable&> m = Ge(ByRef(value2)); 4061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch NotCopyable n1(1), n2(2); 4063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(n1)); 4064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(n2)); 4065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsEmptyTest, ImplementsIsEmpty) { 4068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> container; 4069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, IsEmpty()); 4070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(IsEmpty())); 4072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(1); 4073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(IsEmpty())); 4074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsEmptyTest, WorksWithString) { 4077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string text; 4078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(text, IsEmpty()); 4079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text = "foo"; 4080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(text, Not(IsEmpty())); 4081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text = string("\0", 1); 4082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(text, Not(IsEmpty())); 4083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsEmptyTest, CanDescribeSelf) { 4086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m = IsEmpty(); 4087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is empty", Describe(m)); 4088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("isn't empty", DescribeNegation(m)); 4089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsEmptyTest, ExplainsResult) { 4092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m = IsEmpty(); 4093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> container; 4094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, container)); 4095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size is 1", Explain(m, container)); 4097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SizeIsTest, ImplementsSizeIs) { 4100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> container; 4101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, SizeIs(0)); 4102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(SizeIs(1))); 4103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(SizeIs(0))); 4105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, SizeIs(1)); 4106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(SizeIs(0))); 4108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, SizeIs(2)); 4109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SizeIsTest, WorksWithMap) { 4112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<string, int> container; 4113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, SizeIs(0)); 4114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(SizeIs(1))); 4115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair("foo", 1)); 4116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(SizeIs(0))); 4117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, SizeIs(1)); 4118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.insert(make_pair("bar", 2)); 4119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(SizeIs(0))); 4120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, SizeIs(2)); 4121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SizeIsTest, WorksWithReferences) { 4124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> container; 4125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const vector<int>&> m = SizeIs(1); 4126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(m)); 4127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, m); 4129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SizeIsTest, CanDescribeSelf) { 4132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m = SizeIs(2); 4133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("size is equal to 2", Describe(m)); 4134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("size isn't equal to 2", DescribeNegation(m)); 4135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(SizeIsTest, ExplainsResult) { 4138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m1 = SizeIs(2); 4139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m2 = SizeIs(Lt(2u)); 4140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3)); 4141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m4 = SizeIs(GreaterThan(1)); 4142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> container; 4143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container)); 4144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 0 matches", Explain(m2, container)); 4145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 0 matches", Explain(m3, container)); 4146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1", 4147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m4, container)); 4148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 2 matches", Explain(m1, container)); 4151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container)); 4152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container)); 4153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose size 2 matches, which is 1 more than 1", 4154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m4, container)); 4155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_TYPED_TEST 4158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests ContainerEq with different container types, and 4159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// different element types. 4160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 4162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass ContainerEqTest : public testing::Test {}; 4163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtypedef testing::Types< 4165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch set<int>, 4166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<size_t>, 4167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch multiset<size_t>, 4168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<int> > 4169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ContainerEqTestTypes; 4170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTYPED_TEST_CASE(ContainerEqTest, ContainerEqTestTypes); 4172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that the filled container is equal to itself. 4174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTYPED_TEST(ContainerEqTest, EqualsSelf) { 4175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam my_set(vals, vals + 6); 4177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<TypeParam> m = ContainerEq(my_set); 4178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(my_set)); 4179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, my_set)); 4180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that missing values are reported. 4183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTYPED_TEST(ContainerEqTest, ValueMissing) { 4184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {2, 1, 8, 5}; 4186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam my_set(vals, vals + 6); 4187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam test_set(test_vals, test_vals + 4); 4188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<TypeParam> m = ContainerEq(my_set); 4189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which doesn't have these expected elements: 3", 4191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, test_set)); 4192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that added values are reported. 4195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTYPED_TEST(ContainerEqTest, ValueAdded) { 4196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {1, 2, 3, 5, 8, 46}; 4198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam my_set(vals, vals + 6); 4199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam test_set(test_vals, test_vals + 6); 4200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const TypeParam&> m = ContainerEq(my_set); 4201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set)); 4203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that added and missing values are reported together. 4206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) { 4207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {1, 2, 3, 8, 46}; 4209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam my_set(vals, vals + 6); 4210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam test_set(test_vals, test_vals + 5); 4211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<TypeParam> m = ContainerEq(my_set); 4212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which has these unexpected elements: 46,\n" 4214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and doesn't have these expected elements: 5", 4215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, test_set)); 4216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests duplicated value -- expect no explanation. 4219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTYPED_TEST(ContainerEqTest, DuplicateDifference) { 4220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {1, 2, 3, 5, 8}; 4222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam my_set(vals, vals + 6); 4223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TypeParam test_set(test_vals, test_vals + 5); 4224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const TypeParam&> m = ContainerEq(my_set); 4225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Depending on the container, match may be true or false 4226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // But in any case there should be no explanation. 4227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, test_set)); 4228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_TYPED_TEST 4230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that mutliple missing values are reported. 4232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Using just vector here, so order is predicatble. 4233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, MultipleValuesMissing) { 4234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {2, 1, 5}; 4236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> my_set(vals, vals + 6); 4237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> test_set(test_vals, test_vals + 3); 4238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<vector<int> > m = ContainerEq(my_set); 4239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which doesn't have these expected elements: 3, 8", 4241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, test_set)); 4242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that added values are reported. 4245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Using just vector here, so order is predicatble. 4246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, MultipleValuesAdded) { 4247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46}; 4249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<size_t> my_set(vals, vals + 6); 4250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<size_t> test_set(test_vals, test_vals + 7); 4251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const list<size_t>&> m = ContainerEq(my_set); 4252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which has these unexpected elements: 92, 46", 4254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, test_set)); 4255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that added and missing values are reported together. 4258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) { 4259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {1, 2, 3, 92, 46}; 4261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<size_t> my_set(vals, vals + 6); 4262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<size_t> test_set(test_vals, test_vals + 5); 4263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const list<size_t> > m = ContainerEq(my_set); 4264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which has these unexpected elements: 92, 46,\n" 4266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and doesn't have these expected elements: 5, 8", 4267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, test_set)); 4268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests to see that duplicate elements are detected, 4271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// but (as above) not reported in the explanation. 4272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) { 4273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 4274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int test_vals[] = {1, 2, 3, 5, 8}; 4275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> my_set(vals, vals + 6); 4276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> test_set(test_vals, test_vals + 5); 4277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<vector<int> > m = ContainerEq(my_set); 4278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(my_set)); 4279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 4280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // There is nothing to report when both sets contain all the same values. 4281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, test_set)); 4282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests that ContainerEq works for non-trivial associative containers, 4285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// like maps. 4286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, WorksForMaps) { 4287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<int, std::string> my_map; 4288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch my_map[0] = "a"; 4289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch my_map[1] = "b"; 4290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<int, std::string> test_map; 4292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch test_map[0] = "aa"; 4293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch test_map[1] = "b"; 4294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const map<int, std::string>&> m = ContainerEq(my_map); 4296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(m.Matches(my_map)); 4297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(m.Matches(test_map)); 4298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n" 4300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and doesn't have these expected elements: (0, \"a\")", 4301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, test_map)); 4302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, WorksForNativeArray) { 4305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int a1[] = {1, 2, 3}; 4306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int a2[] = {1, 2, 3}; 4307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int b[] = {1, 2, 4}; 4308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, ContainerEq(a2)); 4310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, Not(ContainerEq(b))); 4311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) { 4314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char a1[][3] = {"hi", "lo"}; 4315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char a2[][3] = {"hi", "lo"}; 4316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char b[][3] = {"lo", "hi"}; 4317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests using ContainerEq() in the first dimension. 4319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, ContainerEq(a2)); 4320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, Not(ContainerEq(b))); 4321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Tests using ContainerEq() in the second dimension. 4323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1]))); 4324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1]))); 4325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) { 4328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a1[] = {1, 2, 3}; 4329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a2[] = {1, 2, 3}; 4330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int b[] = {1, 2, 3, 4}; 4331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int* const p1 = a1; 4333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2)); 4334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b))); 4335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int c[] = {1, 3, 2}; 4337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c))); 4338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ContainerEqExtraTest, CopiesNativeArrayParameter) { 4341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string a1[][3] = { 4342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {"hi", "hello", "ciao"}, 4343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {"bye", "see you", "ciao"} 4344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 4345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string a2[][3] = { 4347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {"hi", "hello", "ciao"}, 4348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {"bye", "see you", "ciao"} 4349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 4350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2); 4352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, m); 4353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a2[0][0] = "ha"; 4355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a1, m); 4356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedByTest, WorksForEmptyContainer) { 4359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const vector<int> numbers; 4360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre())); 4361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1)))); 4362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedByTest, WorksForNonEmptyContainer) { 4365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<unsigned> numbers; 4366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch numbers.push_back(3); 4367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch numbers.push_back(1); 4368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch numbers.push_back(2); 4369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch numbers.push_back(2); 4370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, WhenSortedBy(greater<unsigned>(), 4371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAre(3, 2, 2, 1))); 4372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, Not(WhenSortedBy(greater<unsigned>(), 4373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAre(1, 2, 2, 3)))); 4374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedByTest, WorksForNonVectorContainer) { 4377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<string> words; 4378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("say"); 4379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("hello"); 4380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("world"); 4381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(words, WhenSortedBy(less<string>(), 4382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAre("hello", "say", "world"))); 4383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(words, Not(WhenSortedBy(less<string>(), 4384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAre("say", "hello", "world")))); 4385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedByTest, WorksForNativeArray) { 4388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int numbers[] = {1, 3, 2, 4}; 4389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int sorted_numbers[] = {1, 2, 3, 4}; 4390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre(1, 2, 3, 4))); 4391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, WhenSortedBy(less<int>(), 4392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAreArray(sorted_numbers))); 4393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1, 3, 2, 4)))); 4394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedByTest, CanDescribeSelf) { 4397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2)); 4398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(when sorted) has 2 elements where\n" 4399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #0 is equal to 1,\n" 4400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #1 is equal to 2", 4401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 4402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n" 4403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #0 isn't equal to 1, or\n" 4404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #1 isn't equal to 2", 4405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 4406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedByTest, ExplainsMatchResult) { 4409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {2, 1}; 4410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match", 4411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a)); 4412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which is { 1, 2 } when sorted", 4413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a)); 4414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// WhenSorted() is a simple wrapper on WhenSortedBy(). Hence we don't 4417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// need to test it as exhaustively as we test the latter. 4418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForEmptyContainer) { 4420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const vector<int> numbers; 4421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, WhenSorted(ElementsAre())); 4422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(numbers, Not(WhenSorted(ElementsAre(1)))); 4423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForNonEmptyContainer) { 4426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<string> words; 4427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("3"); 4428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("1"); 4429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("2"); 4430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch words.push_back("2"); 4431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(words, WhenSorted(ElementsAre("1", "2", "2", "3"))); 4432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(words, Not(WhenSorted(ElementsAre("3", "1", "2", "2")))); 4433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForMapTypes) { 4436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<string, int> word_counts; 4437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch word_counts["and"] = 1; 4438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch word_counts["the"] = 1; 4439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch word_counts["buffalo"] = 2; 4440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(word_counts, WhenSorted(ElementsAre( 4441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair("and", 1), Pair("buffalo", 2), Pair("the", 1)))); 4442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(word_counts, Not(WhenSorted(ElementsAre( 4443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair("and", 1), Pair("the", 1), Pair("buffalo", 2))))); 4444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForMultiMapTypes) { 4447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch multimap<int, int> ifib; 4448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ifib.insert(make_pair(8, 6)); 4449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ifib.insert(make_pair(2, 3)); 4450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ifib.insert(make_pair(1, 1)); 4451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ifib.insert(make_pair(3, 4)); 4452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ifib.insert(make_pair(1, 2)); 4453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ifib.insert(make_pair(5, 5)); 4454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(ifib, WhenSorted(ElementsAre(Pair(1, 1), 4455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(1, 2), 4456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(2, 3), 4457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(3, 4), 4458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(5, 5), 4459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(8, 6)))); 4460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(ifib, Not(WhenSorted(ElementsAre(Pair(8, 6), 4461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(2, 3), 4462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(1, 1), 4463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(3, 4), 4464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(1, 2), 4465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(5, 5))))); 4466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForPolymorphicMatcher) { 4469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::deque<int> d; 4470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.push_back(2); 4471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.push_back(1); 4472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2))); 4473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1)))); 4474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForVectorConstRefMatcher) { 4477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::deque<int> d; 4478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.push_back(2); 4479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch d.push_back(1); 4480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2); 4481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(d, WhenSorted(vector_match)); 4482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1); 4483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(d, Not(WhenSorted(not_vector_match))); 4484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Deliberately bare pseudo-container. 4487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Offers only begin() and end() accessors, yielding InputIterator. 4488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename T> 4489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass Streamlike { 4490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 4491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class ConstIter; 4492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 4493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef ConstIter const_iterator; 4494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef T value_type; 4495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename InIter> 4497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike(InIter first, InIter last) : remainder_(first, last) {} 4498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const_iterator begin() const { 4500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return const_iterator(this, remainder_.begin()); 4501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const_iterator end() const { 4503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return const_iterator(this, remainder_.end()); 4504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 4507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class ConstIter : public std::iterator<std::input_iterator_tag, 4508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch value_type, 4509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ptrdiff_t, 4510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const value_type*, 4511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const value_type&> { 4512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 4513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConstIter(const Streamlike* s, 4514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename std::list<value_type>::iterator pos) 4515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : s_(s), pos_(pos) {} 4516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const value_type& operator*() const { return *pos_; } 4518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const value_type* operator->() const { return &*pos_; } 4519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ConstIter& operator++() { 4520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s_->remainder_.erase(pos_++); 4521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return *this; 4522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // *iter++ is required to work (see std::istreambuf_iterator). 4525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // (void)iter++ is also required to work. 4526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch class PostIncrProxy { 4527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 4528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit PostIncrProxy(const value_type& value) : value_(value) {} 4529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch value_type operator*() const { return value_; } 4530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 4531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch value_type value_; 4532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 4533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PostIncrProxy operator++(int) { 4534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PostIncrProxy proxy(**this); 4535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ++(*this); 4536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return proxy; 4537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch friend bool operator==(const ConstIter& a, const ConstIter& b) { 4540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return a.s_ == b.s_ && a.pos_ == b.pos_; 4541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch friend bool operator!=(const ConstIter& a, const ConstIter& b) { 4543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return !(a == b); 4544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 4547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Streamlike* s_; 4548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typename std::list<value_type>::iterator pos_; 4549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch }; 4550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch friend std::ostream& operator<<(std::ostream& os, const Streamlike& s) { 4552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch os << "["; 4553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef typename std::list<value_type>::const_iterator Iter; 4554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* sep = ""; 4555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (Iter it = s.remainder_.begin(); it != s.remainder_.end(); ++it) { 4556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch os << sep << *it; 4557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sep = ","; 4558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch os << "]"; 4560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return os; 4561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mutable std::list<value_type> remainder_; // modified by iteration 4564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 4565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(StreamlikeTest, Iteration) { 4567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + 5); 4569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int>::const_iterator it = s.begin(); 4570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int* ip = a; 4571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch while (it != s.end()) { 4572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SCOPED_TRACE(ip - a); 4573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(*ip++, *it++); 4574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_FORWARD_LIST_ 4578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(BeginEndDistanceIsTest, WorksWithForwardList) { 4579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::forward_list<int> container; 4580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, BeginEndDistanceIs(0)); 4581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(BeginEndDistanceIs(1))); 4582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_front(0); 4583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(BeginEndDistanceIs(0))); 4584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, BeginEndDistanceIs(1)); 4585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_front(0); 4586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, Not(BeginEndDistanceIs(0))); 4587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(container, BeginEndDistanceIs(2)); 4588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_FORWARD_LIST_ 4590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(BeginEndDistanceIsTest, WorksWithNonStdList) { 4592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {1, 2, 3, 4, 5}; 4593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + 5); 4594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, BeginEndDistanceIs(5)); 4595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(BeginEndDistanceIsTest, CanDescribeSelf) { 4598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m = BeginEndDistanceIs(2); 4599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m)); 4600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("distance between begin() and end() isn't equal to 2", 4601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 4602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(BeginEndDistanceIsTest, ExplainsResult) { 4605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m1 = BeginEndDistanceIs(2); 4606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2)); 4607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3)); 4608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1)); 4609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> container; 4610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose distance between begin() and end() 0 doesn't match", 4611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m1, container)); 4612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose distance between begin() and end() 0 matches", 4613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m2, container)); 4614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose distance between begin() and end() 0 matches", 4615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m3, container)); 4616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 4617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "whose distance between begin() and end() 0 doesn't match, which is 1 " 4618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "less than 1", 4619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m4, container)); 4620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch container.push_back(0); 4622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose distance between begin() and end() 2 matches", 4623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m1, container)); 4624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose distance between begin() and end() 2 doesn't match", 4625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m2, container)); 4626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose distance between begin() and end() 2 doesn't match", 4627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m3, container)); 4628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 4629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "whose distance between begin() and end() 2 matches, which is 1 more " 4630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "than 1", 4631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m4, container)); 4632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForStreamlike) { 4635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Streamlike 'container' provides only minimal iterator support. 4636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Its iterators are tagged with input_iterator_tag. 4637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, WhenSorted(ElementsAre(1, 2, 3, 4, 5))); 4640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3)))); 4641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike) { 4644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {2, 1, 4, 5, 3}; 4645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2, 3, 4, 5); 4647f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, WhenSorted(vector_match)); 4648f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3)))); 4649f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4650f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4651f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests using ElementsAre() and ElementsAreArray() with stream-like 4652f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "containers". 4653f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4654f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ElemensAreStreamTest, WorksForStreamlike) { 4655f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {1, 2, 3, 4, 5}; 4656f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4657f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, ElementsAre(1, 2, 3, 4, 5)); 4658f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, Not(ElementsAre(2, 1, 4, 5, 3))); 4659f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4660f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4661f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ElemensAreArrayStreamTest, WorksForStreamlike) { 4662f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {1, 2, 3, 4, 5}; 4663f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4664f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4665f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> expected; 4666f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(1); 4667f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(2); 4668f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(3); 4669f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(4); 4670f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(5); 4671f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, ElementsAreArray(expected)); 4672f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4673f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected[3] = 0; 4674f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, Not(ElementsAreArray(expected))); 4675f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4676f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4677f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ElementsAreTest, WorksWithUncopyable) { 4678f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Uncopyable objs[2]; 4679f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch objs[0].set_value(-3); 4680f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch objs[1].set_value(1); 4681f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(objs, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive))); 4682f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4683f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4684f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(ElementsAreTest, TakesStlContainer) { 4685f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int actual[] = {3, 1, 2}; 4686f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4687f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::list<int> expected; 4688f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(3); 4689f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(1); 4690f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(2); 4691f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(actual, ElementsAreArray(expected)); 4692f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4693f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(4); 4694f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(actual, Not(ElementsAreArray(expected))); 4695f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4696f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4697f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests for UnorderedElementsAreArray() 4698f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4699f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) { 4700f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {0, 1, 2, 3, 4}; 4701f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4702f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch do { 4703f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4704f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a), 4705f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s, &listener)) << listener.str(); 4706f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } while (std::next_permutation(s.begin(), s.end())); 4707f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4708f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4709f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, VectorBool) { 4710f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool a[] = {0, 1, 0, 1, 1}; 4711f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const bool b[] = {1, 0, 1, 1, 0}; 4712f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<bool> expected(a, a + GTEST_ARRAY_SIZE_(a)); 4713f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<bool> actual(b, b + GTEST_ARRAY_SIZE_(b)); 4714f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4715f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected), 4716f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch actual, &listener)) << listener.str(); 4717f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4718f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4719f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, WorksForStreamlike) { 4720f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Streamlike 'container' provides only minimal iterator support. 4721f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Its iterators are tagged with input_iterator_tag, and it has no 4722f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // size() or empty() methods. 4723f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4724f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4725f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4726f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::vector<int> expected; 4727f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(1); 4728f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(2); 4729f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(3); 4730f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(4); 4731f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(5); 4732f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, UnorderedElementsAreArray(expected)); 4733f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4734f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(6); 4735f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, Not(UnorderedElementsAreArray(expected))); 4736f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4737f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4738f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, TakesStlContainer) { 4739f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int actual[] = {3, 1, 2}; 4740f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4741f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::std::list<int> expected; 4742f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(1); 4743f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(2); 4744f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(3); 4745f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(actual, UnorderedElementsAreArray(expected)); 4746f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4747f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch expected.push_back(4); 4748f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected))); 4749f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4750f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4751f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 4752f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4753f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, TakesInitializerList) { 4754f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4755f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, UnorderedElementsAreArray({1, 2, 3, 4, 5})); 4756f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, Not(UnorderedElementsAreArray({1, 2, 3, 4, 6}))); 4757f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4758f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4759f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) { 4760f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const string a[5] = {"a", "b", "c", "d", "e"}; 4761f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, UnorderedElementsAreArray({"a", "b", "c", "d", "e"})); 4762f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, Not(UnorderedElementsAreArray({"a", "b", "c", "d", "ef"}))); 4763f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4764f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4765f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) { 4766f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4767f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, UnorderedElementsAreArray( 4768f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)})); 4769f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, Not(UnorderedElementsAreArray( 4770f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)}))); 4771f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4772f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4773f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedElementsAreArrayTest, 4774f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch TakesInitializerListOfDifferentTypedMatchers) { 4775f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4776f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The compiler cannot infer the type of the initializer list if its 4777f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // elements have different types. We must explicitly specify the 4778f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // unified element type in this case. 4779f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int> >( 4780f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)})); 4781f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int> >( 4782f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)}))); 4783f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4784f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4785f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_INITIALIZER_LIST_ 4786f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4787f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass UnorderedElementsAreTest : public testing::Test { 4788f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 4789f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch typedef std::vector<int> IntVec; 4790f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 4791f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4792f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, WorksWithUncopyable) { 4793f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Uncopyable objs[2]; 4794f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch objs[0].set_value(-3); 4795f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch objs[1].set_value(1); 4796f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(objs, 4797f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UnorderedElementsAre(Truly(ValueIsPositive), UncopyableIs(-3))); 4798f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4799f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4800f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) { 4801f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {1, 2, 3}; 4802f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4803f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch do { 4804f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4805f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), 4806f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s, &listener)) << listener.str(); 4807f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } while (std::next_permutation(s.begin(), s.end())); 4808f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4809f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4810f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) { 4811f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {1, 2, 3}; 4812f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4813f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<Matcher<int> > mv; 4814f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv.push_back(1); 4815f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv.push_back(2); 4816f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv.push_back(2); 4817f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // The element with value '3' matches nothing: fail fast. 4818f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4819f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv), 4820f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s, &listener)) << listener.str(); 4821f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4822f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4823f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, WorksForStreamlike) { 4824f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Streamlike 'container' provides only minimal iterator support. 4825f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Its iterators are tagged with input_iterator_tag, and it has no 4826f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // size() or empty() methods. 4827f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[5] = {2, 1, 4, 5, 3}; 4828f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a)); 4829f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4830f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5)); 4831f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(s, Not(UnorderedElementsAre(2, 2, 3, 4, 5))); 4832f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4833f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4834f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// One naive implementation of the matcher runs in O(N!) time, which is too 4835f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// slow for many real-world inputs. This test shows that our matcher can match 4836f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 100 inputs very quickly (a few milliseconds). An O(100!) is 10^158 4837f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// iterations and obviously effectively incomputable. 4838f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// [ RUN ] UnorderedElementsAreTest.Performance 4839f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// [ OK ] UnorderedElementsAreTest.Performance (4 ms) 4840f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, Performance) { 4841f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> s; 4842f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<Matcher<int> > mv; 4843f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (int i = 0; i < 100; ++i) { 4844f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s.push_back(i); 4845f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv.push_back(_); 4846f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4847f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv[50] = Eq(0); 4848f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4849f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv), 4850f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s, &listener)) << listener.str(); 4851f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4852f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4853f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Another variant of 'Performance' with similar expectations. 4854f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// [ RUN ] UnorderedElementsAreTest.PerformanceHalfStrict 4855f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// [ OK ] UnorderedElementsAreTest.PerformanceHalfStrict (4 ms) 4856f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) { 4857f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> s; 4858f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<Matcher<int> > mv; 4859f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (int i = 0; i < 100; ++i) { 4860f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s.push_back(i); 4861f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (i & 1) { 4862f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv.push_back(_); 4863f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 4864f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mv.push_back(i); 4865f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4866f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 4867f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4868f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv), 4869f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch s, &listener)) << listener.str(); 4870f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4871f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4872f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailMessageCountWrong) { 4873f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> v; 4874f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(4); 4875f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4876f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), 4877f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v, &listener)) << listener.str(); 4878f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(listener.str(), Eq("which has 1 element")); 4879f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4880f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4881f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) { 4882f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> v; 4883f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4884f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), 4885f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v, &listener)) << listener.str(); 4886f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(listener.str(), Eq("")); 4887f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4888f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4889f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) { 4890f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> v; 4891f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(1); 4892f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(1); 4893f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4894f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2), 4895f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v, &listener)) << listener.str(); 4896f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4897f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener.str(), 4898f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("where the following matchers don't match any elements:\n" 4899f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "matcher #1: is equal to 2")); 4900f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4901f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4902f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) { 4903f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> v; 4904f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(1); 4905f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(2); 4906f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4907f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1), 4908f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v, &listener)) << listener.str(); 4909f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4910f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener.str(), 4911f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("where the following elements don't match any matchers:\n" 4912f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #1: 2")); 4913f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4914f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4915f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement) { 4916f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<int> v; 4917f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(2); 4918f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back(3); 4919f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4920f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2), 4921f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v, &listener)) << listener.str(); 4922f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4923f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener.str(), 4924f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("where" 4925f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " the following matchers don't match any elements:\n" 4926f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "matcher #0: is equal to 1\n" 4927f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and" 4928f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " where" 4929f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " the following elements don't match any matchers:\n" 4930f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #1: 3")); 4931f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4932f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4933f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Test helper for formatting element, matcher index pairs in expectations. 4934f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochstatic string EMString(int element, int matcher) { 4935f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss; 4936f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ss << "(element #" << element << ", matcher #" << matcher << ")"; 4937f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return ss.str(); 4938f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4939f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4940f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) { 4941f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // A situation where all elements and matchers have a match 4942f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // associated with them, but the max matching is not perfect. 4943f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<string> v; 4944f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back("a"); 4945f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back("b"); 4946f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch v.push_back("c"); 4947f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StringMatchResultListener listener; 4948f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(ExplainMatchResult( 4949f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch UnorderedElementsAre("a", "a", AnyOf("b", "c")), v, &listener)) 4950f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << listener.str(); 4951f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4952f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch string prefix = 4953f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "where no permutation of the elements can satisfy all matchers, " 4954f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and the closest match is 2 of 3 matchers with the " 4955f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "pairings:\n"; 4956f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4957f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // We have to be a bit loose here, because there are 4 valid max matches. 4958f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4959f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch listener.str(), 4960f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch AnyOf(prefix + "{\n " + EMString(0, 0) + 4961f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ",\n " + EMString(1, 2) + "\n}", 4962f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch prefix + "{\n " + EMString(0, 1) + 4963f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ",\n " + EMString(1, 2) + "\n}", 4964f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch prefix + "{\n " + EMString(0, 0) + 4965f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ",\n " + EMString(2, 2) + "\n}", 4966f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch prefix + "{\n " + EMString(0, 1) + 4967f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ",\n " + EMString(2, 2) + "\n}")); 4968f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4969f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4970f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, Describe) { 4971f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()), 4972f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("is empty")); 4973f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4974f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe<IntVec>(UnorderedElementsAre(345)), 4975f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("has 1 element and that element is equal to 345")); 4976f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4977f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe<IntVec>(UnorderedElementsAre(111, 222, 333)), 4978f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("has 3 elements and there exists some permutation " 4979f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "of elements such that:\n" 4980f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #0 is equal to 111, and\n" 4981f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #1 is equal to 222, and\n" 4982f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #2 is equal to 333")); 4983f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4984f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 4985f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(UnorderedElementsAreTest, DescribeNegation) { 4986f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(DescribeNegation<IntVec>(UnorderedElementsAre()), 4987f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("isn't empty")); 4988f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4989f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation<IntVec>(UnorderedElementsAre(345)), 4990f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("doesn't have 1 element, or has 1 element that isn't equal to 345")); 4991f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT( 4992f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)), 4993f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Eq("doesn't have 3 elements, or there exists no permutation " 4994f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "of elements such that:\n" 4995f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #0 is equal to 123, and\n" 4996f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #1 is equal to 234, and\n" 4997f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #2 is equal to 345")); 4998f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 4999f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5000f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace { 5001f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5002f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Used as a check on the more complex max flow method used in the 5003f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// real testing::internal::FindMaxBipartiteMatching. This method is 5004f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// compatible but runs in worst-case factorial time, so we only 5005f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// use it in testing for small problem sizes. 5006f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Graph> 5007f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BacktrackingMaxBPMState { 5008f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 5009f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Does not take ownership of 'g'. 5010f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) { } 5011f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5012f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementMatcherPairs Compute() { 5013f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) { 5014f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return best_so_far_; 5015f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5016f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_used_.assign(graph_->LhsSize(), kUnused); 5017f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs_used_.assign(graph_->RhsSize(), kUnused); 5018f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) { 5019f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matches_.clear(); 5020f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch RecurseInto(irhs); 5021f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (best_so_far_.size() == graph_->RhsSize()) 5022f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch break; 5023f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5024f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return best_so_far_; 5025f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5026f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5027f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 5028f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const size_t kUnused = static_cast<size_t>(-1); 5029f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5030f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void PushMatch(size_t lhs, size_t rhs) { 5031f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matches_.push_back(ElementMatcherPair(lhs, rhs)); 5032f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_used_[lhs] = rhs; 5033f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs_used_[rhs] = lhs; 5034f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (matches_.size() > best_so_far_.size()) { 5035f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch best_so_far_ = matches_; 5036f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5037f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5038f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5039f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void PopMatch() { 5040f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const ElementMatcherPair& back = matches_.back(); 5041f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs_used_[back.first] = kUnused; 5042f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs_used_[back.second] = kUnused; 5043f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch matches_.pop_back(); 5044f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5045f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5046f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool RecurseInto(size_t irhs) { 5047f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (rhs_used_[irhs] != kUnused) { 5048f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 5049f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5050f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) { 5051f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (lhs_used_[ilhs] != kUnused) { 5052f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch continue; 5053f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5054f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!graph_->HasEdge(ilhs, irhs)) { 5055f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch continue; 5056f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5057f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PushMatch(ilhs, irhs); 5058f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (best_so_far_.size() == graph_->RhsSize()) { 5059f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 5060f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5061f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) { 5062f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!RecurseInto(mi)) return false; 5063f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5064f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PopMatch(); 5065f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5066f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 5067f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5068f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5069f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Graph* graph_; // not owned 5070f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<size_t> lhs_used_; 5071f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<size_t> rhs_used_; 5072f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementMatcherPairs matches_; 5073f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementMatcherPairs best_so_far_; 5074f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 5075f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5076f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Graph> 5077f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst size_t BacktrackingMaxBPMState<Graph>::kUnused; 5078f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5079f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace 5080f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5081f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Implement a simple backtracking algorithm to determine if it is possible 5082f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// to find one element per matcher, without reusing elements. 5083f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochtemplate <typename Graph> 5084f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochElementMatcherPairs 5085f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochFindBacktrackingMaxBPM(const Graph& g) { 5086f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return BacktrackingMaxBPMState<Graph>(&g).Compute(); 5087f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5088f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5089f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BacktrackingBPMTest : public ::testing::Test { }; 5090f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5091f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests the MaxBipartiteMatching algorithm with square matrices. 5092f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The single int param is the # of nodes on each of the left and right sides. 5093f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BipartiteTest : public ::testing::TestWithParam<int> { }; 5094f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5095f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Verify all match graphs up to some moderate number of edges. 5096f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_P(BipartiteTest, Exhaustive) { 5097f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int nodes = GetParam(); 5098f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix graph(nodes, nodes); 5099f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch do { 5100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementMatcherPairs matches = 5101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::FindMaxBipartiteMatching(graph); 5102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size()) 5103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "graph: " << graph.DebugString(); 5104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Check that all elements of matches are in the graph. 5105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Check that elements of first and second are unique. 5106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<bool> seen_element(graph.LhsSize()); 5107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::vector<bool> seen_matcher(graph.RhsSize()); 5108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch SCOPED_TRACE(PrintToString(matches)); 5109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i < matches.size(); ++i) { 5110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t ilhs = matches[i].first; 5111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t irhs = matches[i].second; 5112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(graph.HasEdge(ilhs, irhs)); 5113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(seen_element[ilhs]); 5114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(seen_matcher[irhs]); 5115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch seen_element[ilhs] = true; 5116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch seen_matcher[irhs] = true; 5117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } while (graph.NextGraph()); 5119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochINSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteTest, 5122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ::testing::Range(0, 5)); 5123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Parameterized by a pair interpreted as (LhsSize, RhsSize). 5125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BipartiteNonSquareTest 5126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public ::testing::TestWithParam<std::pair<size_t, size_t> > { 5127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 5128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_F(BipartiteNonSquareTest, SimpleBacktracking) { 5130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // ....... 5131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 0:-----\ : 5132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 1:---\ | : 5133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 2:---\ | : 5134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 3:-\ | | : 5135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // :.......: 5136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 0 1 2 5137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix g(4, 3); 5138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch static const int kEdges[][2] = {{0, 2}, {1, 1}, {2, 1}, {3, 0}}; 5139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i < GTEST_ARRAY_SIZE_(kEdges); ++i) { 5140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch g.SetEdge(kEdges[i][0], kEdges[i][1], true); 5141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(FindBacktrackingMaxBPM(g), 5143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ElementsAre(Pair(3, 0), 5144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(AnyOf(1, 2), 1), 5145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Pair(0, 2))) << g.DebugString(); 5146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Verify a few nonsquare matrices. 5149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_P(BipartiteNonSquareTest, Exhaustive) { 5150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t nlhs = GetParam().first; 5151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t nrhs = GetParam().second; 5152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix graph(nlhs, nrhs); 5153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch do { 5154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), 5155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::FindMaxBipartiteMatching(graph).size()) 5156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "graph: " << graph.DebugString() 5157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "\nbacktracking: " 5158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << PrintToString(FindBacktrackingMaxBPM(graph)) 5159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "\nmax flow: " 5160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << PrintToString(internal::FindMaxBipartiteMatching(graph)); 5161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } while (graph.NextGraph()); 5162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochINSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteNonSquareTest, 5165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::Values( 5166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(1, 2), 5167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(2, 1), 5168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(3, 2), 5169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(2, 3), 5170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(4, 1), 5171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(1, 4), 5172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(4, 3), 5173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(3, 4))); 5174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BipartiteRandomTest 5176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch : public ::testing::TestWithParam<std::pair<int, int> > { 5177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 5178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Verifies a large sample of larger graphs. 5180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST_P(BipartiteRandomTest, LargerNets) { 5181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int nodes = GetParam().first; 5182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int iters = GetParam().second; 5183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchMatrix graph(nodes, nodes); 5184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::internal::Int32 seed = GTEST_FLAG(random_seed); 5186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (seed == 0) { 5187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch seed = static_cast<testing::internal::Int32>(time(NULL)); 5188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (; iters > 0; --iters, ++seed) { 5191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch srand(static_cast<int>(seed)); 5192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch graph.Randomize(); 5193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), 5194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::FindMaxBipartiteMatching(graph).size()) 5195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << " graph: " << graph.DebugString() 5196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch << "\nTo reproduce the failure, rerun the test with the flag" 5197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " --" << GTEST_FLAG_PREFIX_ << "random_seed=" << seed; 5198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Test argument is a std::pair<int, int> representing (nodes, iters). 5202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochINSTANTIATE_TEST_CASE_P(Samples, BipartiteRandomTest, 5203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch testing::Values( 5204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(5, 10000), 5205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(6, 5000), 5206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(7, 2000), 5207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(8, 500), 5208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::make_pair(9, 100))); 5209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests IsReadableTypeName(). 5211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) { 5213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("int")); 5214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("const unsigned char*")); 5215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>")); 5216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)")); 5217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) { 5220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName")); 5221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]")); 5222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass")); 5223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) { 5226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE( 5227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch IsReadableTypeName("basic_string<char, std::char_traits<char> >")); 5228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >")); 5229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) { 5232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)")); 5233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests JoinAsTuple(). 5236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(JoinAsTupleTest, JoinsEmptyTuple) { 5238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", JoinAsTuple(Strings())); 5239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(JoinAsTupleTest, JoinsOneTuple) { 5242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* fields[] = {"1"}; 5243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1))); 5244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(JoinAsTupleTest, JoinsTwoTuple) { 5247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* fields[] = {"1", "a"}; 5248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2))); 5249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(JoinAsTupleTest, JoinsTenTuple) { 5252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; 5253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)", 5254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch JoinAsTuple(Strings(fields, fields + 10))); 5255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests FormatMatcherDescription(). 5258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) { 5260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is even", 5261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FormatMatcherDescription(false, "IsEven", Strings())); 5262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("not (is even)", 5263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FormatMatcherDescription(true, "IsEven", Strings())); 5264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* params[] = {"5"}; 5266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("equals 5", 5267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FormatMatcherDescription(false, "Equals", 5268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Strings(params, params + 1))); 5269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* params2[] = {"5", "8"}; 5271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("is in range (5, 8)", 5272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch FormatMatcherDescription(false, "IsInRange", 5273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Strings(params2, params2 + 2))); 5274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests PolymorphicMatcher::mutable_impl(). 5277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PolymorphicMatcherTest, CanAccessMutableImpl) { 5278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42)); 5279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DivisibleByImpl& impl = m.mutable_impl(); 5280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(42, impl.divider()); 5281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch impl.set_divider(0); 5283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(0, m.mutable_impl().divider()); 5284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests PolymorphicMatcher::impl(). 5287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PolymorphicMatcherTest, CanAccessImpl) { 5288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42)); 5289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const DivisibleByImpl& impl = m.impl(); 5290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(42, impl.divider()); 5291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(MatcherTupleTest, ExplainsMatchFailure) { 5294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss1; 5295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)), 5296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch make_tuple('a', 10), &ss1); 5297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", ss1.str()); // Successful match. 5298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss2; 5300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))), 5301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch make_tuple(2, 'b'), &ss2); 5302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(" Expected arg #0: is > 5\n" 5303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: 2, which is 3 less than 5\n" 5304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Expected arg #1: is equal to 'a' (97, 0x61)\n" 5305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: 'b' (98, 0x62)\n", 5306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ss2.str()); // Failed match where both arguments need explanation. 5307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch stringstream ss3; 5309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))), 5310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch make_tuple(2, 'a'), &ss3); 5311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ(" Expected arg #0: is > 5\n" 5312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " Actual: 2, which is 3 less than 5\n", 5313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ss3.str()); // Failed match where only one argument needs 5314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // explanation. 5315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Tests Each(). 5318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EachTest, ExplainsMatchResultCorrectly) { 5320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch set<int> a; // empty 5321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<set<int> > m = Each(2); 5323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, a)); 5324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<const int(&)[1]> n = Each(1); // NOLINT 5326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int b[1] = {1}; 5328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(n, b)); 5329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch n = Each(3); 5331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose element #0 doesn't match", Explain(n, b)); 5332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.insert(1); 5334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.insert(2); 5335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch a.insert(3); 5336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Each(GreaterThan(0)); 5337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(m, a)); 5338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch m = Each(GreaterThan(10)); 5340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10", 5341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(m, a)); 5342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EachTest, DescribesItselfCorrectly) { 5345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m = Each(1); 5346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("only contains elements that is equal to 1", Describe(m)); 5347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Matcher<vector<int> > m2 = Not(m); 5349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2)); 5350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EachTest, MatchesVectorWhenAllElementsMatch) { 5353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> some_vector; 5354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(some_vector, Each(1)); 5355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch some_vector.push_back(3); 5356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(some_vector, Not(Each(1))); 5357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(some_vector, Each(3)); 5358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch some_vector.push_back(1); 5359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch some_vector.push_back(2); 5360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(some_vector, Not(Each(3))); 5361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(some_vector, Each(Lt(3.5))); 5362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<string> another_vector; 5364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_vector.push_back("fee"); 5365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_vector, Each(string("fee"))); 5366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_vector.push_back("fie"); 5367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_vector.push_back("foe"); 5368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_vector.push_back("fum"); 5369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_vector, Not(Each(string("fee")))); 5370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EachTest, MatchesMapWhenAllElementsMatch) { 5373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<const char*, int> my_map; 5374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const char* bar = "a string"; 5375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch my_map[bar] = 2; 5376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(my_map, Each(make_pair(bar, 2))); 5377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch map<string, int> another_map; 5379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1))); 5380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_map["fee"] = 1; 5381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1))); 5382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_map["fie"] = 2; 5383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_map["foe"] = 3; 5384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch another_map["fum"] = 4; 5385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_map, Not(Each(make_pair(string("fee"), 1)))); 5386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_map, Not(Each(make_pair(string("fum"), 1)))); 5387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(another_map, Each(Pair(_, Gt(0)))); 5388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EachTest, AcceptsMatcher) { 5391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {1, 2, 3}; 5392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, Each(Gt(0))); 5393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(a, Not(Each(Gt(1)))); 5394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(EachTest, WorksForNativeArrayAsTuple) { 5397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int a[] = {1, 2}; 5398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int* const pointer = a; 5399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(pointer, 2), Each(Gt(0))); 5400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(make_tuple(pointer, 2), Not(Each(Gt(1)))); 5401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// For testing Pointwise(). 5404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass IsHalfOfMatcher { 5405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 5406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch template <typename T1, typename T2> 5407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool MatchAndExplain(const tuple<T1, T2>& a_pair, 5408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch MatchResultListener* listener) const { 5409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (get<0>(a_pair) == get<1>(a_pair)/2) { 5410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "where the second is " << get<1>(a_pair); 5411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return true; 5412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 5413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *listener << "where the second/2 is " << get<1>(a_pair)/2; 5414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return false; 5415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeTo(ostream* os) const { 5419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "are a pair where the first is half of the second"; 5420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void DescribeNegationTo(ostream* os) const { 5423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *os << "are a pair where the first isn't half of the second"; 5424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 5425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 5426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochPolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() { 5428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return MakePolymorphicMatcher(IsHalfOfMatcher()); 5429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, DescribesSelf) { 5432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> rhs; 5433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(1); 5434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(2); 5435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(3); 5436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs); 5437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("contains 3 values, where each value and its corresponding value " 5438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "in { 1, 2, 3 } are a pair where the first is half of the second", 5439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 5440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some " 5441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "index i where x and the i-th value of { 1, 2, 3 } are a pair " 5442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "where the first isn't half of the second", 5443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 5444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, MakesCopyOfRhs) { 5447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<signed char> rhs; 5448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(2); 5449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(4); 5450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int lhs[] = {1, 2}; 5452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs); 5453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, m); 5454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Changing rhs now shouldn't affect m, which made a copy of rhs. 5456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(6); 5457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, m); 5458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, WorksForLhsNativeArray) { 5461f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int lhs[] = {1, 2, 3}; 5462f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> rhs; 5463f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(2); 5464f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(4); 5465f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(6); 5466f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Pointwise(Lt(), rhs)); 5467f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs))); 5468f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5469f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5470f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, WorksForRhsNativeArray) { 5471f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[] = {1, 2, 3}; 5472f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> lhs; 5473f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs.push_back(2); 5474f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs.push_back(4); 5475f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs.push_back(6); 5476f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Pointwise(Gt(), rhs)); 5477f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(Pointwise(Lt(), rhs))); 5478f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5479f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5480f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 5481f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5482f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, WorksForRhsInitializerList) { 5483f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const vector<int> lhs{2, 4, 6}; 5484f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Pointwise(Gt(), {1, 2, 3})); 5485f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7}))); 5486f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5487f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5488f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_INITIALIZER_LIST_ 5489f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5490f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, RejectsWrongSize) { 5491f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[2] = {1, 2}; 5492f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[1] = {0}; 5493f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs))); 5494f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which contains 2 values", 5495f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(Pointwise(Gt(), rhs), lhs)); 5496f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5497f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs2[3] = {0, 1, 2}; 5498f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2))); 5499f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5500f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5501f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, RejectsWrongContent) { 5502f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5503f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {2, 6, 4}; 5504f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs))); 5505f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, " 5506f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "where the second/2 is 3", 5507f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(Pointwise(IsHalfOf(), rhs), lhs)); 5508f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5509f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5510f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, AcceptsCorrectContent) { 5511f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5512f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {2, 4, 6}; 5513f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Pointwise(IsHalfOf(), rhs)); 5514f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs), lhs)); 5515f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5516f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5517f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(PointwiseTest, AllowsMonomorphicInnerMatcher) { 5518f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5519f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {2, 4, 6}; 5520f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf(); 5521f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Pointwise(m1, rhs)); 5522f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(Pointwise(m1, rhs), lhs)); 5523f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5524f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This type works as a tuple<const double&, const int&> can be 5525f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implicitly cast to tuple<double, int>. 5526f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<tuple<double, int> > m2 = IsHalfOf(); 5527f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Pointwise(m2, rhs)); 5528f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("", Explain(Pointwise(m2, rhs), lhs)); 5529f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5530f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5531f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, DescribesSelf) { 5532f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> rhs; 5533f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(1); 5534f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(2); 5535f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(3); 5536f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const vector<int>&> m = UnorderedPointwise(IsHalfOf(), rhs); 5537f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 5538f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "has 3 elements and there exists some permutation of elements such " 5539f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "that:\n" 5540f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #0 and 1 are a pair where the first is half of the second, " 5541f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and\n" 5542f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #1 and 2 are a pair where the first is half of the second, " 5543f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and\n" 5544f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #2 and 3 are a pair where the first is half of the second", 5545f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Describe(m)); 5546f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ( 5547f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "doesn't have 3 elements, or there exists no permutation of elements " 5548f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "such that:\n" 5549f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #0 and 1 are a pair where the first is half of the second, " 5550f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and\n" 5551f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #1 and 2 are a pair where the first is half of the second, " 5552f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "and\n" 5553f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch " - element #2 and 3 are a pair where the first is half of the second", 5554f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DescribeNegation(m)); 5555f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5556f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5557f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, MakesCopyOfRhs) { 5558f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch list<signed char> rhs; 5559f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(2); 5560f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(4); 5561f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5562f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int lhs[] = {2, 1}; 5563f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs); 5564f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, m); 5565f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5566f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Changing rhs now shouldn't affect m, which made a copy of rhs. 5567f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(6); 5568f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, m); 5569f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5570f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5571f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, WorksForLhsNativeArray) { 5572f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int lhs[] = {1, 2, 3}; 5573f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> rhs; 5574f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(4); 5575f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(6); 5576f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch rhs.push_back(2); 5577f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(Lt(), rhs)); 5578f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs))); 5579f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5580f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5581f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, WorksForRhsNativeArray) { 5582f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[] = {1, 2, 3}; 5583f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch vector<int> lhs; 5584f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs.push_back(4); 5585f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs.push_back(2); 5586f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch lhs.push_back(6); 5587f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(Gt(), rhs)); 5588f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs))); 5589f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5590f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5591f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if GTEST_HAS_STD_INITIALIZER_LIST_ 5592f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5593f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, WorksForRhsInitializerList) { 5594f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const vector<int> lhs{2, 4, 6}; 5595f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(Gt(), {5, 1, 3})); 5596f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7}))); 5597f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5598f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5599f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // GTEST_HAS_STD_INITIALIZER_LIST_ 5600f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5601f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, RejectsWrongSize) { 5602f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[2] = {1, 2}; 5603f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[1] = {0}; 5604f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs))); 5605f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("which has 2 elements", 5606f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(UnorderedPointwise(Gt(), rhs), lhs)); 5607f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5608f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs2[3] = {0, 1, 2}; 5609f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs2))); 5610f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5611f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5612f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, RejectsWrongContent) { 5613f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5614f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {2, 6, 6}; 5615f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, Not(UnorderedPointwise(IsHalfOf(), rhs))); 5616f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_EQ("where the following elements don't match any matchers:\n" 5617f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "element #1: 2", 5618f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs)); 5619f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5620f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5621f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) { 5622f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5623f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {2, 4, 6}; 5624f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs)); 5625f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5626f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5627f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder) { 5628f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5629f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {6, 4, 2}; 5630f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs)); 5631f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5632f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5633f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochTEST(UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher) { 5634f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const double lhs[3] = {1, 2, 3}; 5635f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const int rhs[3] = {4, 6, 2}; 5636f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf(); 5637f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(m1, rhs)); 5638f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5639f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This type works as a tuple<const double&, const int&> can be 5640f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // implicitly cast to tuple<double, int>. 5641f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch const Matcher<tuple<double, int> > m2 = IsHalfOf(); 5642f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch EXPECT_THAT(lhs, UnorderedPointwise(m2, rhs)); 5643f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 5644f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5645f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace gmock_matchers_test 5646f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace testing 5647