1c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Copyright 2007, Google Inc. 2c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// All rights reserved. 3c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 4c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Redistribution and use in source and binary forms, with or without 5c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// modification, are permitted provided that the following conditions are 6c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// met: 7c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 8c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// * Redistributions of source code must retain the above copyright 9c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// notice, this list of conditions and the following disclaimer. 10c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// * Redistributions in binary form must reproduce the above 11c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// copyright notice, this list of conditions and the following disclaimer 12c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// in the documentation and/or other materials provided with the 13c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// distribution. 14c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// * Neither the name of Google Inc. nor the names of its 15c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// contributors may be used to endorse or promote products derived from 16c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// this software without specific prior written permission. 17c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 18c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 30c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Author: wan@google.com (Zhanyong Wan) 31c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 32c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Google Mock - a framework for writing C++ mock classes. 33c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 34c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This file tests some commonly used argument matchers. 35c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 36dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gmock/gmock-matchers.h" 37c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 38c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <string.h> 39c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <functional> 40c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <iostream> 41c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <list> 42c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <map> 43c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <set> 44c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <sstream> 45c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <string> 46c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <utility> 47c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <vector> 48dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gmock/gmock.h" 49dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gtest/gtest.h" 50dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gtest/gtest-spi.h" 51c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 52c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace testing { 53c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 54c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace internal { 55c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring JoinAsTuple(const Strings& fields); 56c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace internal 57c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 58c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace gmock_matchers_test { 59c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 603345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::list; 61c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::make_pair; 62c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::map; 63c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::multimap; 643345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::multiset; 653345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::ostream; 66c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::pair; 673345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::set; 68c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::stringstream; 693345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::tr1::get; 70c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::tr1::make_tuple; 713345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::tr1::tuple; 723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing std::vector; 73c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::A; 74c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::AllArgs; 75c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::AllOf; 76c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::An; 77c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::AnyOf; 78c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ByRef; 79c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ContainsRegex; 80c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::DoubleEq; 81c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::EndsWith; 82c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Eq; 83c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ExplainMatchResult; 84c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Field; 85c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::FloatEq; 86c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Ge; 87c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Gt; 88c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::HasSubstr; 89c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::IsNull; 90c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Key; 91c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Le; 92c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Lt; 93c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MakeMatcher; 94c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MakePolymorphicMatcher; 95c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MatchResultListener; 96c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Matcher; 97c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MatcherCast; 98c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MatcherInterface; 99c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Matches; 100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MatchesRegex; 101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::NanSensitiveDoubleEq; 102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::NanSensitiveFloatEq; 103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Ne; 104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Not; 105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::NotNull; 106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Pair; 107c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Pointee; 1083345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickusing testing::Pointwise; 109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::PolymorphicMatcher; 110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Property; 111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Ref; 112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ResultOf; 113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StartsWith; 114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StrCaseEq; 115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StrCaseNe; 116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StrEq; 117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StrNe; 118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Truly; 119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::TypedEq; 120c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Value; 121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::_; 122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::DummyMatchResultListener; 123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::ExplainMatchFailureTupleTo; 124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::FloatingEqMatcher; 125dc0f95d653279beabeb9817299e2902918ba123eKristian Monsenusing testing::internal::FormatMatcherDescription; 126dc0f95d653279beabeb9817299e2902918ba123eKristian Monsenusing testing::internal::IsReadableTypeName; 127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::JoinAsTuple; 128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::RE; 129c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::StreamMatchResultListener; 130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::String; 131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::StringMatchResultListener; 132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::Strings; 133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::linked_ptr; 134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::scoped_ptr; 135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::string; 136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// For testing ExplainMatchResultTo(). 138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass GreaterThanMatcher : public MatcherInterface<int> { 139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {} 141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1423345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick virtual void DescribeTo(ostream* os) const { 143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is > " << rhs_; 144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 146c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual bool MatchAndExplain(int lhs, 147c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MatchResultListener* listener) const { 148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int diff = lhs - rhs_; 149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (diff > 0) { 150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is " << diff << " more than " << rhs_; 151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (diff == 0) { 152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is the same as " << rhs_; 153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is " << -diff << " less than " << rhs_; 155c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return lhs > rhs_; 158c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int rhs_; 162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 164c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMatcher<int> GreaterThan(int n) { 165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return MakeMatcher(new GreaterThanMatcher(n)); 166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 168dc0f95d653279beabeb9817299e2902918ba123eKristian Monsenstring OfType(const string& type_name) { 169dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#if GTEST_HAS_RTTI 170dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen return " (of type " + type_name + ")"; 171dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#else 172dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen return ""; 173dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#endif 174dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen} 175dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns the description of the given matcher. 177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring Describe(const Matcher<T>& m) { 179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss; 180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m.DescribeTo(&ss); 181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return ss.str(); 182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 183c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns the description of the negation of the given matcher. 185c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring DescribeNegation(const Matcher<T>& m) { 187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss; 188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m.DescribeNegationTo(&ss); 189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return ss.str(); 190c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns the reason why x matches, or doesn't match, m. 193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename MatcherType, typename Value> 194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring Explain(const MatcherType& m, const Value& x) { 1953345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick StringMatchResultListener listener; 1963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick ExplainMatchResult(m, x, &listener); 1973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return listener.str(); 198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 200c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchResultListenerTest, StreamingWorks) { 201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener; 202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch listener << "hi" << 5; 203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("hi5", listener.str()); 204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Streaming shouldn't crash when the underlying ostream is NULL. 206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DummyMatchResultListener dummy; 207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch dummy << "hi" << 5; 208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 210c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchResultListenerTest, CanAccessUnderlyingStream) { 211c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(DummyMatchResultListener().stream() == NULL); 212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL); 213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream()); 215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 216c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 217c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchResultListenerTest, IsInterestedWorks) { 218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(StringMatchResultListener().IsInterested()); 219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested()); 220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(DummyMatchResultListener().IsInterested()); 222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested()); 223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Makes sure that the MatcherInterface<T> interface doesn't 226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// change. 227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass EvenMatcherImpl : public MatcherInterface<int> { 228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual bool MatchAndExplain(int x, 230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MatchResultListener* /* listener */) const { 231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return x % 2 == 0; 232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2343345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick virtual void DescribeTo(ostream* os) const { 235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is an even number"; 236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We deliberately don't define DescribeNegationTo() and 239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // ExplainMatchResultTo() here, to make sure the definition of these 240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // two methods is optional. 241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 243c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Makes sure that the MatcherInterface API doesn't change. 244c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) { 245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EvenMatcherImpl m; 246c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests implementing a monomorphic matcher using MatchAndExplain(). 249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass NewEvenMatcherImpl : public MatcherInterface<int> { 251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual bool MatchAndExplain(int x, MatchResultListener* listener) const { 253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const bool match = x % 2 == 0; 254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that we can stream to a listener directly. 255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "value % " << 2; 256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (listener->stream() != NULL) { 257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that we can stream to a listener's underlying stream 258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // too. 259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener->stream() << " == " << (x % 2); 260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 261c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return match; 262c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2643345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick virtual void DescribeTo(ostream* os) const { 265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is an even number"; 266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 269c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) { 270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl); 271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(2)); 272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(3)); 273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("value % 2 == 0", Explain(m, 2)); 274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("value % 2 == 1", Explain(m, 3)); 275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 276c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests default-constructing a matcher. 278c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, CanBeDefaultConstructed) { 279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m; 280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Matcher<T> can be constructed from a MatcherInterface<T>*. 283c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, CanBeConstructedFromMatcherInterface) { 284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MatcherInterface<int>* impl = new EvenMatcherImpl; 285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m(impl); 286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(4)); 287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(5)); 288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 289c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that value can be used in place of Eq(value). 291c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, CanBeImplicitlyConstructedFromValue) { 292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = 5; 293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(5)); 294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(6)); 295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that NULL can be used in place of Eq(NULL). 298c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) { 299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int*> m1 = NULL; 300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(NULL)); 301c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(&n)); 303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that matchers are copyable. 306c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, IsCopyable) { 307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests the copy constructor. 308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<bool> m1 = Eq(false); 309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(false)); 310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(true)); 311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests the assignment operator. 313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m1 = Eq(true); 314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(true)); 315c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(false)); 316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Matcher<T>::DescribeTo() calls 319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// MatcherInterface<T>::DescribeTo(). 320c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, CanDescribeItself) { 321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an even number", 322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(Matcher<int>(new EvenMatcherImpl))); 323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests Matcher<T>::MatchAndExplain(). 326c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTest, MatchAndExplain) { 327c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = GreaterThan(0); 328c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener1; 329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.MatchAndExplain(42, &listener1)); 330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 42 more than 0", listener1.str()); 331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener2; 333c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.MatchAndExplain(-9, &listener2)); 334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 9 less than 0", listener2.str()); 335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a C-string literal can be implicitly converted to a 338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Matcher<string> or Matcher<const string&>. 339c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) { 340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m1 = "hi"; 341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("hi")); 342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches("hello")); 343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m2 = "hi"; 345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("hi")); 346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("hello")); 347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a string object can be implicitly converted to a 350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Matcher<string> or Matcher<const string&>. 351c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) { 352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m1 = string("hi"); 353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("hi")); 354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches("hello")); 355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m2 = string("hi"); 357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("hi")); 358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("hello")); 359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MakeMatcher() constructs a Matcher<T> from a 362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// MatcherInterface* without requiring the user to explicitly 363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// write the type. 364c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) { 365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const MatcherInterface<int>* dummy_impl = NULL; 366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = MakeMatcher(dummy_impl); 367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 368c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MakePolymorphicMatcher() can construct a polymorphic 370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// matcher from its implementation using the old API. 3713345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickconst int g_bar = 1; 372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass ReferencesBarOrIsZeroImpl { 373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch template <typename T> 375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool MatchAndExplain(const T& x, 376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MatchResultListener* /* listener */) const { 377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const void* p = &x; 3783345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return p == &g_bar || x == 0; 379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3813345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeTo(ostream* os) const { *os << "g_bar or zero"; } 382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3833345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeNegationTo(ostream* os) const { 3843345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick *os << "doesn't reference g_bar and is not zero"; 385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This function verifies that MakePolymorphicMatcher() returns a 389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// PolymorphicMatcher<T> where T is the argument's type. 390c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochPolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() { 391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl()); 392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 394c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) { 395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Using a polymorphic matcher to match a reference type. 396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m1 = ReferencesBarOrIsZero(); 397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(0)); 398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that the identity of a by-reference argument is preserved. 3993345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_TRUE(m1.Matches(g_bar)); 400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(1)); 4013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("g_bar or zero", Describe(m1)); 402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Using a polymorphic matcher to match a value type. 404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m2 = ReferencesBarOrIsZero(); 405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0.0)); 406c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(0.1)); 4073345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("g_bar or zero", Describe(m2)); 408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests implementing a polymorphic matcher using MatchAndExplain(). 411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 412c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass PolymorphicIsEvenImpl { 413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 4143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeTo(ostream* os) const { *os << "is even"; } 415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 4163345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeNegationTo(ostream* os) const { 417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is odd"; 418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch template <typename T> 421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool MatchAndExplain(const T& x, MatchResultListener* listener) const { 422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that we can stream to the listener directly. 423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "% " << 2; 424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (listener->stream() != NULL) { 425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that we can stream to the listener's underlying stream 426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // too. 427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener->stream() << " == " << (x % 2); 428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return (x % 2) == 0; 430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 433c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochPolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() { 434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return MakePolymorphicMatcher(PolymorphicIsEvenImpl()); 435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 437c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) { 438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Using PolymorphicIsEven() as a Matcher<int>. 439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m1 = PolymorphicIsEven(); 440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(42)); 441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(43)); 442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is even", Describe(m1)); 443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> not_m1 = Not(m1); 445c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is odd", Describe(not_m1)); 446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("% 2 == 0", Explain(m1, 42)); 448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Using PolymorphicIsEven() as a Matcher<char>. 450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<char> m2 = PolymorphicIsEven(); 451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches('\x42')); 452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches('\x43')); 453c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is even", Describe(m2)); 454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<char> not_m2 = Not(m2); 456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is odd", Describe(not_m2)); 457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("% 2 == 0", Explain(m2, '\x42')); 459c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<T>(m) works when m is a polymorphic matcher. 462c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromPolymorphicMatcher) { 463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = MatcherCast<int>(Eq(5)); 464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(5)); 465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(6)); 466c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// For testing casting matchers between compatible types. 469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass IntValue { 470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // An int can be statically (although not implicitly) cast to a 472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // IntValue. 473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit IntValue(int a_value) : value_(a_value) {} 474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int value() const { return value_; } 476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int value_; 478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// For testing casting matchers between compatible types. 481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool IsPositiveIntValue(const IntValue& foo) { 482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return foo.value() > 0; 483c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T 486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// can be statically converted to U. 487c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromCompatibleType) { 488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m1 = Eq(2.0); 489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(2)); 491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(3)); 492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<IntValue> m3 = Truly(IsPositiveIntValue); 494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m4 = MatcherCast<int>(m3); 495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // In the following, the arguments 1 and 0 are statically converted 496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // to IntValue objects, and then tested by the IsPositiveIntValue() 497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // predicate. 498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m4.Matches(1)); 499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m4.Matches(0)); 500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>. 503c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromConstReferenceToNonReference) { 504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m1 = Eq(0); 505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0)); 507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(1)); 508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>. 511c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromReferenceToNonReference) { 512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m1 = Eq(0); 513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0)); 515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(1)); 516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>. 519c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromNonReferenceToConstReference) { 520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(0); 521c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m2 = MatcherCast<const int&>(m1); 522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0)); 523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(1)); 524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<T&>(m) works when m is a Matcher<T>. 527c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromNonReferenceToReference) { 528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(0); 529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = MatcherCast<int&>(m1); 530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(n)); 532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 1; 533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(n)); 534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<T>(m) works when m is a Matcher<T>. 537c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherCastTest, FromSameType) { 538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(0); 539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m2 = MatcherCast<int>(m1); 540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0)); 541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(1)); 542c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass Base {}; 545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass Derived : public Base {}; 546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher. 548c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromPolymorphicMatcher) { 549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<char> m2 = SafeMatcherCast<char>(Eq(32)); 550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(' ')); 551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches('\n')); 552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where 555c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// T and U are arithmetic types and T can be losslessly converted to 556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// U. 557c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) { 558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m1 = DoubleEq(1.0); 559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m2 = SafeMatcherCast<float>(m1); 560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(1.0f)); 561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(2.0f)); 562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 563c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a')); 564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches('a')); 565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches('b')); 566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U 569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// are pointers or references to a derived and a base class, correspondingly. 570c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromBaseClass) { 571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Derived d, d2; 572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<Base*> m1 = Eq(&d); 573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1); 574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(&d)); 575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(&d2)); 576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<Base&> m3 = Ref(d); 578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3); 579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m4.Matches(d)); 580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m4.Matches(d2)); 581c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>. 584c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromConstReferenceToReference) { 585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m1 = Ref(n); 587c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = SafeMatcherCast<int&>(m1); 588c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n1 = 0; 589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(n)); 590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(n1)); 591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>. 594c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromNonReferenceToConstReference) { 595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(0); 596c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1); 597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0)); 598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(1)); 599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>. 602c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromNonReferenceToReference) { 603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(0); 604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = SafeMatcherCast<int&>(m1); 605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(n)); 607c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 1; 608c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(n)); 609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>. 612c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SafeMatcherCastTest, FromSameType) { 613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(0); 614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m2 = SafeMatcherCast<int>(m1); 615c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(0)); 616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(1)); 617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that A<T>() matches any value of type T. 620c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ATest, MatchesAnyValue) { 621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests a matcher for a value type. 622c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m1 = A<double>(); 623c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(91.43)); 624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(-15.32)); 625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests a matcher for a reference type. 627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a = 2; 628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int b = -6; 629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = A<int&>(); 630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(a)); 631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(b)); 632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 634c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that A<T>() describes itself properly. 635c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ATest, CanDescribeSelf) { 636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is anything", Describe(A<bool>())); 637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that An<T>() matches any value of type T. 640c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnTest, MatchesAnyValue) { 641c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests a matcher for a value type. 642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = An<int>(); 643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(9143)); 644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(-1532)); 645c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests a matcher for a reference type. 647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a = 2; 648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int b = -6; 649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = An<int&>(); 650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(a)); 651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(b)); 652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that An<T>() describes itself properly. 655c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnTest, CanDescribeSelf) { 656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is anything", Describe(An<int>())); 657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that _ can be used as a matcher for any type and matches any 660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// value of that type. 661c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(UnderscoreTest, MatchesAnyValue) { 662c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Uses _ as a matcher for a value type. 663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = _; 664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(123)); 665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(-242)); 666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Uses _ as a matcher for a reference type. 668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool a = false; 669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const bool b = true; 670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const bool&> m2 = _; 671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(a)); 672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(b)); 673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 674c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that _ describes itself properly. 676c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(UnderscoreTest, CanDescribeSelf) { 677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = _; 678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is anything", Describe(m)); 679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Eq(x) matches any value equal to x. 682c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(EqTest, MatchesEqualValue) { 683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 2 C-strings with same content but different addresses. 684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char a1[] = "hi"; 685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char a2[] = "hi"; 686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m1 = Eq(a1); 688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(a1)); 689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(a2)); 690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Eq(v) describes itself properly. 693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass Unprintable { 695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Unprintable() : c_('a') {} 697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool operator==(const Unprintable& /* rhs */) { return true; } 699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch char c_; 701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 703c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(EqTest, CanDescribeSelf) { 704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<Unprintable> m = Eq(Unprintable()); 705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to 1-byte object <61>", Describe(m)); 706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Eq(v) can be used to match any type that supports 709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// comparing with type T, where T is v's type. 710c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(EqTest, IsPolymorphic) { 711c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Eq(1); 712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(1)); 713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(2)); 714c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<char> m2 = Eq(1); 716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches('\1')); 717c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches('a')); 718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that TypedEq<T>(v) matches values of type T that's equal to v. 721c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TypedEqTest, ChecksEqualityForGivenType) { 722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<char> m1 = TypedEq<char>('a'); 723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches('a')); 724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches('b')); 725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m2 = TypedEq<int>(6); 727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(6)); 728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(7)); 729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that TypedEq(v) describes itself properly. 732c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TypedEqTest, CanDescribeSelf) { 733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2))); 734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that TypedEq<T>(v) has type Matcher<T>. 737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Type<T>::IsTypeOf(v) compiles iff the type of value v is T, where T 739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// is a "bare" type (i.e. not in the form of const U or U&). If v's 740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// type is not T, the compiler will generate a message about 741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// "undefined referece". 742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct Type { 744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static bool IsTypeOf(const T& /* v */) { return true; } 745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch template <typename T2> 747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static void IsTypeOf(T2 v); 748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 750c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TypedEqTest, HasSpecifiedType) { 751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verfies that the type of TypedEq<T>(v) is Matcher<T>. 752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5)); 753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5)); 754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 756c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ge(v) matches anything >= v. 757c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GeTest, ImplementsGreaterThanOrEqual) { 758c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Ge(0); 759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(1)); 760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(0)); 761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(-1)); 762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ge(v) describes itself properly. 765c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GeTest, CanDescribeSelf) { 766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Ge(5); 767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is >= 5", Describe(m)); 768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Gt(v) matches anything > v. 771c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GtTest, ImplementsGreaterThan) { 772c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m1 = Gt(0); 773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(1.0)); 774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(0.0)); 775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(-1.0)); 776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Gt(v) describes itself properly. 779c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GtTest, CanDescribeSelf) { 780c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Gt(5); 781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is > 5", Describe(m)); 782c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 784c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Le(v) matches anything <= v. 785c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(LeTest, ImplementsLessThanOrEqual) { 786c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<char> m1 = Le('b'); 787c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches('a')); 788c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches('b')); 789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches('c')); 790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Le(v) describes itself properly. 793c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(LeTest, CanDescribeSelf) { 794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Le(5); 795c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is <= 5", Describe(m)); 796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 797c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Lt(v) matches anything < v. 799c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(LtTest, ImplementsLessThan) { 800c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m1 = Lt("Hello"); 801c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("Abc")); 802c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches("Hello")); 803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches("Hello, world!")); 804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Lt(v) describes itself properly. 807c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(LtTest, CanDescribeSelf) { 808c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Lt(5); 809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is < 5", Describe(m)); 810c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 812c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ne(v) matches anything != v. 813c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NeTest, ImplementsNotEqual) { 814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m1 = Ne(0); 815c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(1)); 816c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(-1)); 817c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(0)); 818c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 820c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ne(v) describes itself properly. 821c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NeTest, CanDescribeSelf) { 822c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Ne(5); 823c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to 5", Describe(m)); 824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 825c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 826c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that IsNull() matches any NULL pointer of any type. 827c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(IsNullTest, MatchesNullPointer) { 828c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int*> m1 = IsNull(); 829c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int* p1 = NULL; 830c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 831c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(p1)); 832c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(&n)); 833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 834c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m2 = IsNull(); 835c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* p2 = NULL; 836c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(p2)); 837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("hi")); 838c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if !GTEST_OS_SYMBIAN 840c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Nokia's Symbian compiler generates: 841c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // gmock-matchers.h: ambiguous access to overloaded function 842c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)' 843c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing:: 844c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // MatcherInterface<void *> *)' 845c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // gmock-matchers.h: (point of instantiation: 'testing:: 846c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()') 847c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // gmock-matchers.h: (instantiating: 'testing::PolymorphicMatc 848c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<void*> m3 = IsNull(); 849c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void* p3 = NULL; 850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(p3)); 851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef))); 852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif 853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 854c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 855c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(IsNullTest, LinkedPtr) { 856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<linked_ptr<int> > m = IsNull(); 857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<int> null_p; 858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<int> non_null_p(new int); 859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 860c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(null_p)); 861c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(non_null_p)); 862c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 864c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(IsNullTest, ReferenceToConstLinkedPtr) { 865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const linked_ptr<double>&> m = IsNull(); 866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<double> null_p; 867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<double> non_null_p(new double); 868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 869c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(null_p)); 870c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(non_null_p)); 871c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 872c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 873c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(IsNullTest, ReferenceToConstScopedPtr) { 874c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const scoped_ptr<double>&> m = IsNull(); 875c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const scoped_ptr<double> null_p; 876c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const scoped_ptr<double> non_null_p(new double); 877c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 878c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(null_p)); 879c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(non_null_p)); 880c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 881c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that IsNull() describes itself properly. 883c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(IsNullTest, CanDescribeSelf) { 884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int*> m = IsNull(); 885c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is NULL", Describe(m)); 886c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't NULL", DescribeNegation(m)); 887c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 888c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that NotNull() matches any non-NULL pointer of any type. 890c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotNullTest, MatchesNonNullPointer) { 891c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int*> m1 = NotNull(); 892c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int* p1 = NULL; 893c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(p1)); 895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(&n)); 896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m2 = NotNull(); 898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* p2 = NULL; 899c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(p2)); 900c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("hi")); 901c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 903c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotNullTest, LinkedPtr) { 904c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<linked_ptr<int> > m = NotNull(); 905c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<int> null_p; 906c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<int> non_null_p(new int); 907c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 908c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(null_p)); 909c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(non_null_p)); 910c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 911c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 912c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotNullTest, ReferenceToConstLinkedPtr) { 913c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const linked_ptr<double>&> m = NotNull(); 914c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<double> null_p; 915c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const linked_ptr<double> non_null_p(new double); 916c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 917c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(null_p)); 918c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(non_null_p)); 919c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 920c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 921c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotNullTest, ReferenceToConstScopedPtr) { 922c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const scoped_ptr<double>&> m = NotNull(); 923c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const scoped_ptr<double> null_p; 924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const scoped_ptr<double> non_null_p(new double); 925c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 926c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(null_p)); 927c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(non_null_p)); 928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 930c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that NotNull() describes itself properly. 931c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotNullTest, CanDescribeSelf) { 932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int*> m = NotNull(); 933c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't NULL", Describe(m)); 934c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 935c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ref(variable) matches an argument that references 937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 'variable'. 938c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(RefTest, MatchesSameVariable) { 939c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a = 0; 940c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int b = 0; 941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m = Ref(a); 942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(b)); 944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ref(variable) describes itself properly. 947c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(RefTest, CanDescribeSelf) { 948c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 5; 949c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m = Ref(n); 950c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss; 951c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ss << "references the variable @" << &n << " 5"; 952c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(string(ss.str()), Describe(m)); 953c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Test that Ref(non_const_varialbe) can be used as a matcher for a 956c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// const reference. 957c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(RefTest, CanBeUsedAsMatcherForConstReference) { 958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a = 0; 959c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int b = 0; 960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m = Ref(a); 961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(b)); 963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 964c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 965c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ref(variable) is covariant, i.e. Ref(derived) can be 966c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// used wherever Ref(base) can be used (Ref(derived) is a sub-type 967c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// of Ref(base), but not vice versa. 968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 969c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(RefTest, IsCovariant) { 970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Base base, base2; 971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Derived derived; 972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Base&> m1 = Ref(base); 973c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(base)); 974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(base2)); 975c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(derived)); 976c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 977c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m1 = Ref(derived); 978c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(derived)); 979c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(base)); 980c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(base2)); 981c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 982c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 983c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(RefTest, ExplainsResult) { 984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n), 986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StartsWith("which is located @")); 987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 988c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int m = 0; 989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m), 990c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StartsWith("which is located @")); 991c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 992c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests string comparison matchers. 994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 995c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrEqTest, MatchesEqualString) { 996c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m = StrEq(string("Hello")); 997c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches("Hello")); 998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches("hello")); 999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1001c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m2 = StrEq("Hello"); 1002c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("Hello")); 1003c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("Hi")); 1004c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1005c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1006c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrEqTest, CanDescribeSelf) { 1007ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3"); 1008ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"", 1009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 1010c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1011c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch string str("01204500800"); 1012c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[3] = '\0'; 1013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m2 = StrEq(str); 1014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2)); 1015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = '\0'; 1016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m3 = StrEq(str); 1017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3)); 1018c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1020c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrNeTest, MatchesUnequalString) { 1021c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m = StrNe("Hello"); 1022c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches("")); 1023c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1024c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches("Hello")); 1025c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1026c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m2 = StrNe(string("Hello")); 1027c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("hello")); 1028c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("Hello")); 1029c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1030c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1031c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrNeTest, CanDescribeSelf) { 1032c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m = StrNe("Hi"); 1033c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to \"Hi\"", Describe(m)); 1034c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1035c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1036c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) { 1037c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m = StrCaseEq(string("Hello")); 1038c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches("Hello")); 1039c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches("hello")); 1040c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches("Hi")); 1041c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1042c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1043c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m2 = StrCaseEq("Hello"); 1044c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("hello")); 1045c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("Hi")); 1046c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1047c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1048c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) { 1049c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch string str1("oabocdooeoo"); 1050c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch string str2("OABOCDOOEOO"); 1051c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m0 = StrCaseEq(str1); 1052c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m0.Matches(str2 + string(1, '\0'))); 1053c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1054c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[3] = str2[3] = '\0'; 1055c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m1 = StrCaseEq(str1); 1056c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(str2)); 1057c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1058c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[0] = str1[6] = str1[7] = str1[10] = '\0'; 1059c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str2[0] = str2[6] = str2[7] = str2[10] = '\0'; 1060c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m2 = StrCaseEq(str1); 1061c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[9] = str2[9] = '\0'; 1062c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(str2)); 1063c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1064c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> m3 = StrCaseEq(str1); 1065c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(str2)); 1066c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1067c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(str2 + "x")); 1068c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str2.append(1, '\0'); 1069c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(str2)); 1070c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(string(str2, 0, 9))); 1071c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1072c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1073c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrCaseEqTest, CanDescribeSelf) { 1074c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m = StrCaseEq("Hi"); 1075c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m)); 1076c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1077c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1078c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) { 1079c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m = StrCaseNe("Hello"); 1080c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches("Hi")); 1081c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1082c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches("Hello")); 1083c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches("hello")); 1084c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1085c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m2 = StrCaseNe(string("Hello")); 1086c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("")); 1087c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("Hello")); 1088c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1089c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1090c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StrCaseNeTest, CanDescribeSelf) { 1091c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m = StrCaseNe("Hi"); 1092c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m)); 1093c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1094c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1095c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr() works for matching string-typed values. 1096c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(HasSubstrTest, WorksForStringClasses) { 1097c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<string> m1 = HasSubstr("foo"); 1098c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(string("I love food."))); 1099c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(string("tofo"))); 1100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const std::string&> m2 = HasSubstr("foo"); 1102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(std::string("I love food."))); 1103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(std::string("tofo"))); 1104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr() works for matching C-string-typed values. 1107c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(HasSubstrTest, WorksForCStrings) { 1108c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<char*> m1 = HasSubstr("foo"); 1109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food."))); 1110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo"))); 1111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const char*> m2 = HasSubstr("foo"); 1114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("I love food.")); 1115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("tofo")); 1116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(NULL)); 1117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr(s) describes itself properly. 1120c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(HasSubstrTest, CanDescribeSelf) { 1121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<string> m = HasSubstr("foo\n\""); 1122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m)); 1123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1125c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(KeyTest, CanDescribeSelf) { 1126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const pair<std::string, int>&> m = Key("foo"); 1127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m)); 1128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m)); 1129c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1131c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(KeyTest, ExplainsResult) { 1132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<pair<int, bool> > m = Key(GreaterThan(10)); 1133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose first field is a value which is 5 less than 10", 1134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_pair(5, true))); 1135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose first field is a value which is 5 more than 10", 1136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_pair(15, true))); 1137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1139c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(KeyTest, MatchesCorrectly) { 1140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch pair<int, std::string> p(25, "foo"); 1141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Key(25)); 1142c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Key(42))); 1143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Key(Ge(20))); 1144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Key(Lt(25)))); 1145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1146c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1147c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(KeyTest, SafelyCastsInnerMatcher) { 1148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> is_positive = Gt(0); 1149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> is_negative = Lt(0); 1150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch pair<char, bool> p('a', true); 1151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Key(is_positive)); 1152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Key(is_negative))); 1153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1155c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(KeyTest, InsideContainsUsingMap) { 11563345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick map<int, char> container; 1157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(1, 'a')); 1158c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(2, 'b')); 1159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(4, 'c')); 1160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Key(1))); 1161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Not(Contains(Key(3)))); 1162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1164c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(KeyTest, InsideContainsUsingMultimap) { 11653345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick multimap<int, char> container; 1166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(1, 'a')); 1167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(2, 'b')); 1168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(4, 'c')); 1169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1170c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Not(Contains(Key(25)))); 1171c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(25, 'd')); 1172c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Key(25))); 1173c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(25, 'e')); 1174c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Key(25))); 1175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Key(1))); 1177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Not(Contains(Key(3)))); 1178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1180c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PairTest, Typing) { 1181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Test verifies the following type conversions can be compiled. 1182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42); 1183c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const pair<const char*, int> > m2 = Pair("foo", 42); 1184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<pair<const char*, int> > m3 = Pair("foo", 42); 1185c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<pair<int, const std::string> > m4 = Pair(25, "42"); 1187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<pair<const std::string, int> > m5 = Pair("25", 42); 1188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1190c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PairTest, CanDescribeSelf) { 1191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42); 1192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has a first field that is equal to \"foo\"" 1193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ", and has a second field that is equal to 42", 1194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m1)); 1195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has a first field that isn't equal to \"foo\"" 1196c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ", or has a second field that isn't equal to 42", 1197c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m1)); 1198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Double and triple negation (1 or 2 times not and description of negation). 1199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42)); 1200c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has a first field that isn't equal to 13" 1201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ", and has a second field that is equal to 42", 1202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m2)); 1203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1205c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PairTest, CanExplainMatchResultTo) { 1206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If neither field matches, Pair() should explain about the first 1207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // field. 1208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0)); 1209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose first field does not match, which is 1 less than 0", 1210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_pair(-1, -2))); 1211c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If the first field matches but the second doesn't, Pair() should 1213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain about the second field. 1214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose second field does not match, which is 2 less than 0", 1215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_pair(1, -2))); 1216c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If the first field doesn't match but the second does, Pair() 1218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // should explain about the first field. 1219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose first field does not match, which is 1 less than 0", 1220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_pair(-1, 2))); 1221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If both fields match, Pair() should explain about them both. 1223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose both fields match, where the first field is a value " 1224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "which is 1 more than 0, and the second field is a value " 1225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "which is 2 more than 0", 1226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_pair(1, 2))); 1227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If only the first match has an explanation, only this explanation should 1229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // be printed. 1230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0); 1231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose both fields match, where the first field is a value " 1232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "which is 1 more than 0", 1233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(explain_first, make_pair(1, 0))); 1234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If only the second match has an explanation, only this explanation should 1236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // be printed. 1237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0)); 1238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose both fields match, where the second field is a value " 1239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "which is 1 more than 0", 1240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(explain_second, make_pair(0, 1))); 1241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1243c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PairTest, MatchesCorrectly) { 1244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch pair<int, std::string> p(25, "foo"); 1245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1246c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Both fields match. 1247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Pair(25, "foo")); 1248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o"))); 1249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 'first' doesnt' match, but 'second' matches. 1251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(42, "foo"))); 1252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(Lt(25), "foo"))); 1253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 'first' matches, but 'second' doesn't match. 1255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(25, "bar"))); 1256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(25, Not("foo")))); 1257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Neither field matches. 1259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(13, "bar"))); 1260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a")))); 1261c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1262c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1263c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PairTest, SafelyCastsInnerMatchers) { 1264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> is_positive = Gt(0); 1265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> is_negative = Lt(0); 1266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch pair<char, bool> p('a', true); 1267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Pair(is_positive, _)); 1268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(is_negative, _))); 1269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Pair(_, is_positive)); 1270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(p, Not(Pair(_, is_negative))); 1271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1273c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PairTest, InsideContainsUsingMap) { 12743345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick map<int, char> container; 1275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(1, 'a')); 1276c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(2, 'b')); 1277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch container.insert(make_pair(4, 'c')); 1278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Pair(1, 'a'))); 1279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Pair(1, _))); 1280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Contains(Pair(_, 'a'))); 1281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(container, Not(Contains(Pair(3, _)))); 1282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests StartsWith(s). 1285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1286c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StartsWithTest, MatchesStringWithGivenPrefix) { 1287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const char*> m1 = StartsWith(string("")); 1288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("Hi")); 1289c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("")); 1290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const string&> m2 = StartsWith("Hi"); 1293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("Hi")); 1294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("Hi Hi!")); 1295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("High")); 1296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("H")); 1297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(" Hi")); 1298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1300c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StartsWithTest, CanDescribeSelf) { 1301c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const std::string> m = StartsWith("Hi"); 1302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("starts with \"Hi\"", Describe(m)); 1303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests EndsWith(s). 1306c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1307c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(EndsWithTest, MatchesStringWithGivenSuffix) { 1308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const char*> m1 = EndsWith(""); 1309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("Hi")); 1310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("")); 1311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const string&> m2 = EndsWith(string("Hi")); 1314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("Hi")); 1315c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("Wow Hi Hi")); 1316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("Super Hi")); 1317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("i")); 1318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("Hi ")); 1319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1321c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(EndsWithTest, CanDescribeSelf) { 1322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const std::string> m = EndsWith("Hi"); 1323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("ends with \"Hi\"", Describe(m)); 1324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests MatchesRegex(). 1327c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1328c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) { 1329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const char*> m1 = MatchesRegex("a.*z"); 1330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("az")); 1331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("abcz")); 1332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1333c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z")); 1335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("azbz")); 1336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("az1")); 1337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("1az")); 1338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1340c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchesRegexTest, CanDescribeSelf) { 1341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const std::string> m1 = MatchesRegex(string("Hi.*")); 1342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1)); 1343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m2 = MatchesRegex(new RE("a.*")); 1345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2)); 1346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests ContainsRegex(). 1349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1350c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsRegexTest, MatchesStringContainingGivenRegex) { 1351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const char*> m1 = ContainsRegex(string("a.*z")); 1352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("az")); 1353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("0abcz1")); 1354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z")); 1357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("azbz")); 1358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("az1")); 1359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches("1a")); 1360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1362c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsRegexTest, CanDescribeSelf) { 1363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const std::string> m1 = ContainsRegex("Hi.*"); 1364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1)); 1365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> m2 = ContainsRegex(new RE("a.*")); 1367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2)); 1368c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests for wide strings. 1371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_STD_WSTRING 1372c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrEqTest, MatchesEqual) { 1373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello")); 1374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m2 = StrEq(L"Hello"); 1379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hello")); 1380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D")); 1384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E")); 1385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::wstring str(L"01204500800"); 1387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[3] = L'\0'; 1388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m4 = StrEq(str); 1389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m4.Matches(str)); 1390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m5 = StrEq(str); 1392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m5.Matches(str)); 1393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1395c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrEqTest, CanDescribeSelf) { 1396ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v"); 1397ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"", 1398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 1399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"", 1402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m2)); 1403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::wstring str(L"01204500800"); 1405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[3] = L'\0'; 1406c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m4 = StrEq(str); 1407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4)); 1408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m5 = StrEq(str); 1410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5)); 1411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1412c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1413c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrNeTest, MatchesUnequalString) { 1414c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hello"); 1415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"")); 1416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello")); 1420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1424c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrNeTest, CanDescribeSelf) { 1425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hi"); 1426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m)); 1427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1429c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) { 1430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello")); 1431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"hello")); 1433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"Hi")); 1434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello"); 1437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1441c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) { 1442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::wstring str1(L"oabocdooeoo"); 1443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::wstring str2(L"OABOCDOOEOO"); 1444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m0 = StrCaseEq(str1); 1445c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0'))); 1446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[3] = str2[3] = L'\0'; 1448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m1 = StrCaseEq(str1); 1449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(str2)); 1450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[0] = str1[6] = str1[7] = str1[10] = L'\0'; 1452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str2[0] = str2[6] = str2[7] = str2[10] = L'\0'; 1453c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m2 = StrCaseEq(str1); 1454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[9] = str2[9] = L'\0'; 1455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(str2)); 1456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring&> m3 = StrCaseEq(str1); 1458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(str2)); 1459c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(str2 + L"x")); 1461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str2.append(1, L'\0'); 1462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(str2)); 1463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9))); 1464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1466c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrCaseEqTest, CanDescribeSelf) { 1467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::std::wstring> m = StrCaseEq(L"Hi"); 1468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m)); 1469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1471c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) { 1472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hello"); 1473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"Hi")); 1474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello")); 1479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"")); 1480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1483c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStrCaseNeTest, CanDescribeSelf) { 1484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hi"); 1485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m)); 1486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr() works for matching wstring-typed values. 1489c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideHasSubstrTest, WorksForStringClasses) { 1490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher< ::std::wstring> m1 = HasSubstr(L"foo"); 1491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food."))); 1492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo"))); 1493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo"); 1495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food."))); 1496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo"))); 1497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr() works for matching C-wide-string-typed values. 1500c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideHasSubstrTest, WorksForCStrings) { 1501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<wchar_t*> m1 = HasSubstr(L"foo"); 1502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food."))); 1503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo"))); 1504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const wchar_t*> m2 = HasSubstr(L"foo"); 1507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"I love food.")); 1508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"tofo")); 1509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(NULL)); 1510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr(s) describes itself properly. 1513c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideHasSubstrTest, CanDescribeSelf) { 1514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::std::wstring> m = HasSubstr(L"foo\n\""); 1515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m)); 1516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests StartsWith(s). 1519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1520c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) { 1521c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L"")); 1522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi"); 1527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi Hi!")); 1529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"High")); 1530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"H")); 1531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L" Hi")); 1532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1534c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideStartsWithTest, CanDescribeSelf) { 1535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring> m = StartsWith(L"Hi"); 1536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("starts with L\"Hi\"", Describe(m)); 1537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests EndsWith(s). 1540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1541c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) { 1542c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const wchar_t*> m1 = EndsWith(L""); 1543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi")); 1548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Wow Hi Hi")); 1550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Super Hi")); 1551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"i")); 1552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi ")); 1553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1555c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(StdWideEndsWithTest, CanDescribeSelf) { 1556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::std::wstring> m = EndsWith(L"Hi"); 1557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("ends with L\"Hi\"", Describe(m)); 1558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_STD_WSTRING 1561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_GLOBAL_WSTRING 1563c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrEqTest, MatchesEqual) { 1564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello")); 1565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m2 = StrEq(L"Hello"); 1570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hello")); 1571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D")); 1575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E")); 1576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::wstring str(L"01204500800"); 1578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[3] = L'\0'; 1579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m4 = StrEq(str); 1580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m4.Matches(str)); 1581c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m5 = StrEq(str); 1583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m5.Matches(str)); 1584c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1586c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrEqTest, CanDescribeSelf) { 1587ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen Matcher< ::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v"); 1588ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"", 1589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 1590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D"); 1592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"", 1593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m2)); 1594c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::wstring str(L"01204500800"); 1596c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[3] = L'\0'; 1597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m4 = StrEq(str); 1598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4)); 1599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str[0] = str[6] = str[7] = str[9] = str[10] = L'\0'; 1600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m5 = StrEq(str); 1601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5)); 1602c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1604c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrNeTest, MatchesUnequalString) { 1605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hello"); 1606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"")); 1607c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1608c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello")); 1611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1615c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrNeTest, CanDescribeSelf) { 1616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrNe(L"Hi"); 1617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m)); 1618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1620c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) { 1621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrCaseEq(::wstring(L"Hello")); 1622c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"Hello")); 1623c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"hello")); 1624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"Hi")); 1625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 1626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello"); 1628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"hello")); 1629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi")); 1630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1632c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) { 1633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::wstring str1(L"oabocdooeoo"); 1634c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::wstring str2(L"OABOCDOOEOO"); 1635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m0 = StrCaseEq(str1); 1636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m0.Matches(str2 + ::wstring(1, L'\0'))); 1637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[3] = str2[3] = L'\0'; 1639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m1 = StrCaseEq(str1); 1640c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(str2)); 1641c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[0] = str1[6] = str1[7] = str1[10] = L'\0'; 1643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str2[0] = str2[6] = str2[7] = str2[10] = L'\0'; 1644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m2 = StrCaseEq(str1); 1645c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str1[9] = str2[9] = L'\0'; 1646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(str2)); 1647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring&> m3 = StrCaseEq(str1); 1649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(str2)); 1650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(str2 + L"x")); 1652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch str2.append(1, L'\0'); 1653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(str2)); 1654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(::wstring(str2, 0, 9))); 1655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1657c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrCaseEqTest, CanDescribeSelf) { 1658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::wstring> m = StrCaseEq(L"Hi"); 1659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m)); 1660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1662c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) { 1663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hello"); 1664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(L"Hi")); 1665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(NULL)); 1666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"Hello")); 1667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(L"hello")); 1668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello")); 1670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"")); 1671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hello")); 1672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1674c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStrCaseNeTest, CanDescribeSelf) { 1675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const wchar_t*> m = StrCaseNe(L"Hi"); 1676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m)); 1677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr() works for matching wstring-typed values. 1680c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideHasSubstrTest, WorksForStringClasses) { 1681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher< ::wstring> m1 = HasSubstr(L"foo"); 1682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(::wstring(L"I love food."))); 1683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(::wstring(L"tofo"))); 1684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::wstring&> m2 = HasSubstr(L"foo"); 1686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(::wstring(L"I love food."))); 1687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(::wstring(L"tofo"))); 1688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr() works for matching C-wide-string-typed values. 1691c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideHasSubstrTest, WorksForCStrings) { 1692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<wchar_t*> m1 = HasSubstr(L"foo"); 1693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food."))); 1694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo"))); 1695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const wchar_t*> m2 = HasSubstr(L"foo"); 1698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"I love food.")); 1699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"tofo")); 1700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(NULL)); 1701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that HasSubstr(s) describes itself properly. 1704c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideHasSubstrTest, CanDescribeSelf) { 1705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher< ::wstring> m = HasSubstr(L"foo\n\""); 1706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m)); 1707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests StartsWith(s). 1710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1711c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStartsWithTest, MatchesStringWithGivenPrefix) { 1712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L"")); 1713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1714c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1717c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::wstring&> m2 = StartsWith(L"Hi"); 1718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi Hi!")); 1720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"High")); 1721c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"H")); 1722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L" Hi")); 1723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1725c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideStartsWithTest, CanDescribeSelf) { 1726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring> m = StartsWith(L"Hi"); 1727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("starts with L\"Hi\"", Describe(m)); 1728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests EndsWith(s). 1731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1732c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideEndsWithTest, MatchesStringWithGivenSuffix) { 1733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const wchar_t*> m1 = EndsWith(L""); 1734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"Hi")); 1735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(L"")); 1736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(NULL)); 1737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi")); 1739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Hi")); 1740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Wow Hi Hi")); 1741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches(L"Super Hi")); 1742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"i")); 1743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(L"Hi ")); 1744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1746c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(GlobalWideEndsWithTest, CanDescribeSelf) { 1747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const ::wstring> m = EndsWith(L"Hi"); 1748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("ends with L\"Hi\"", Describe(m)); 1749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_GLOBAL_WSTRING 1752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef ::std::tr1::tuple<long, int> Tuple2; // NOLINT 1755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1756c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Eq() matches a 2-tuple where the first field == the 1757c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// second field. 1758c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Eq2Test, MatchesEqualArguments) { 1759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Eq(); 1760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 5))); 1761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 6))); 1762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Eq() describes itself properly. 1765c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Eq2Test, CanDescribeSelf) { 1766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Eq(); 17673345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are an equal pair", Describe(m)); 1768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ge() matches a 2-tuple where the first field >= the 1771c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// second field. 1772c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Ge2Test, MatchesGreaterThanOrEqualArguments) { 1773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Ge(); 1774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 4))); 1775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 5))); 1776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 6))); 1777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1779c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ge() describes itself properly. 1780c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Ge2Test, CanDescribeSelf) { 1781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Ge(); 17823345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are a pair where the first >= the second", Describe(m)); 1783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1784c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1785c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Gt() matches a 2-tuple where the first field > the 1786c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// second field. 1787c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Gt2Test, MatchesGreaterThanArguments) { 1788c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Gt(); 1789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 4))); 1790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 5))); 1791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 6))); 1792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1793c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Gt() describes itself properly. 1795c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Gt2Test, CanDescribeSelf) { 1796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Gt(); 17973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are a pair where the first > the second", Describe(m)); 1798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1799c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1800c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Le() matches a 2-tuple where the first field <= the 1801c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// second field. 1802c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Le2Test, MatchesLessThanOrEqualArguments) { 1803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Le(); 1804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 6))); 1805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 5))); 1806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 4))); 1807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1808c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Le() describes itself properly. 1810c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Le2Test, CanDescribeSelf) { 1811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Le(); 18123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are a pair where the first <= the second", Describe(m)); 1813c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1815c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Lt() matches a 2-tuple where the first field < the 1816c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// second field. 1817c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Lt2Test, MatchesLessThanArguments) { 1818c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Lt(); 1819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 6))); 1820c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 5))); 1821c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 4))); 1822c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1823c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Lt() describes itself properly. 1825c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Lt2Test, CanDescribeSelf) { 1826c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Lt(); 18273345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are a pair where the first < the second", Describe(m)); 1828c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1829c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1830c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ne() matches a 2-tuple where the first field != the 1831c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// second field. 1832c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Ne2Test, MatchesUnequalArguments) { 1833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Ne(); 1834c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 6))); 1835c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple2(5L, 4))); 1836c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple2(5L, 5))); 1837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1838c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Ne() describes itself properly. 1840c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(Ne2Test, CanDescribeSelf) { 1841c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const Tuple2&> m = Ne(); 18423345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are an unequal pair", Describe(m)); 1843c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1844c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1845c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Not(m) matches any value that doesn't match m. 1846c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotTest, NegatesMatcher) { 1847c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 1848c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Not(Eq(2)); 1849c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(3)); 1850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(2)); 1851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Not(m) describes itself properly. 1854c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotTest, CanDescribeSelf) { 1855c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Not(Eq(5)); 1856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't equal to 5", Describe(m)); 1857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that monomorphic matchers are safely cast by the Not matcher. 1860c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) { 1861c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // greater_than_5 is a monomorphic matcher. 1862c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> greater_than_5 = Gt(5); 1863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1864c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m = Not(greater_than_5); 1865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = Not(greater_than_5); 1866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m3 = Not(m); 1867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1869dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// Helper to allow easy testing of AllOf matchers with num parameters. 1870dc0f95d653279beabeb9817299e2902918ba123eKristian Monsenvoid AllOfMatches(int num, const Matcher<int>& m) { 1871dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen SCOPED_TRACE(Describe(m)); 1872dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(m.Matches(0)); 1873dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen for (int i = 1; i <= num; ++i) { 1874dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_FALSE(m.Matches(i)); 1875dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen } 1876dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(m.Matches(num + 1)); 1877dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen} 1878dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 1879c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that AllOf(m1, ..., mn) matches any value that matches all of 1880c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the given matchers. 1881c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllOfTest, MatchesWhenAllMatch) { 1882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 1883c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Le(2), Ge(1)); 1884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(1)); 1885c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(2)); 1886c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(0)); 1887c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(3)); 1888c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2)); 1890c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(3)); 1891c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(2)); 1892c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(1)); 1893c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(0)); 1894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3)); 1896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(4)); 1897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(3)); 1898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(2)); 1899c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(1)); 1900c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(0)); 1901c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7)); 1903c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(0)); 1904c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(1)); 1905c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(3)); 1906dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 1907dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // The following tests for varying number of sub-matchers. Due to the way 1908dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // the sub-matchers are handled it is enough to test every sub-matcher once 1909dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // with sub-matchers using the same matcher type. Varying matcher types are 1910dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // checked for above. 1911dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(2, AllOf(Ne(1), Ne(2))); 1912dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3))); 1913dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4))); 1914dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5))); 1915dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6))); 1916dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7))); 1917dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), 1918dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Ne(8))); 1919dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), 1920dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Ne(8), Ne(9))); 1921dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), 1922dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Ne(9), Ne(10))); 1923c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1925c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that AllOf(m1, ..., mn) describes itself properly. 1926c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllOfTest, CanDescribeSelf) { 1927c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 1928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Le(2), Ge(1)); 1929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m)); 1930c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1931c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2)); 1932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is > 0) and " 1933c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 1) and " 1934c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(isn't equal to 2))", 1935c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 1936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1938c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3)); 1939c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is > 0) and " 1940c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 1) and " 1941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 2) and " 1942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(isn't equal to 3)))", 1943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 1944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7)); 1947c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is >= 0) and " 1948c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is < 10) and " 1949c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 3) and " 1950c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 5) and " 1951c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(isn't equal to 7))))", 1952c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 1953c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that AllOf(m1, ..., mn) describes its negation properly. 1956c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllOfTest, CanDescribeNegation) { 1957c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 1958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Le(2), Ge(1)); 1959c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't <= 2) or " 1960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(isn't >= 1)", 1961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 1962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2)); 1964c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't > 0) or " 1965c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 1) or " 1966c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(is equal to 2))", 1967c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 1968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1969c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3)); 1971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't > 0) or " 1972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 1) or " 1973c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 2) or " 1974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(is equal to 3)))", 1975c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 1976c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1977c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1978c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7)); 1979c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't >= 0) or " 1980c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't < 10) or " 1981c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 3) or " 1982c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 5) or " 1983c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(is equal to 7))))", 1984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 1985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that monomorphic matchers are safely cast by the AllOf matcher. 1988c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) { 1989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // greater_than_5 and less_than_10 are monomorphic matchers. 1990c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> greater_than_5 = Gt(5); 1991c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> less_than_10 = Lt(10); 1992c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m = AllOf(greater_than_5, less_than_10); 1994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = AllOf(greater_than_5, less_than_10); 1995c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m3 = AllOf(greater_than_5, m2); 1996c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1997c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests that BothOf works when composing itself. 1998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10); 1999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10); 2000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2001c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2002c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllOfTest, ExplainsResult) { 2003c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 2004c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2005c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. Both matchers need to explain. The second 2006c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher doesn't give an explanation, so only the first matcher's 2007c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explanation is printed. 2008c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), Lt(30)); 2009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 15 more than 10", Explain(m, 25)); 2010c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2011c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. Both matchers need to explain. 2012c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20)); 2013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20", 2014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, 30)); 2015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. All matchers need to explain. The second 2017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher doesn't given an explanation. 2018c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20)); 2019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20", 2020c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, 25)); 2021c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2022c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. All matchers need to explain. 2023c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30)); 2024c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, " 2025c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "and which is 10 more than 30", 2026c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, 40)); 2027c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2028c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. The first matcher, which failed, needs to 2029c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain. 2030c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20)); 2031c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 less than 10", Explain(m, 5)); 2032c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2033c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. The second matcher, which failed, needs to 2034c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain. Since it doesn't given an explanation, nothing is 2035c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // printed. 2036c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), Lt(30)); 2037c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 40)); 2038c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2039c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. The second matcher, which failed, needs to 2040c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain. 2041c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AllOf(GreaterThan(10), GreaterThan(20)); 2042c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 less than 20", Explain(m, 15)); 2043c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2044c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2045dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// Helper to allow easy testing of AnyOf matchers with num parameters. 2046dc0f95d653279beabeb9817299e2902918ba123eKristian Monsenvoid AnyOfMatches(int num, const Matcher<int>& m) { 2047dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen SCOPED_TRACE(Describe(m)); 2048dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_FALSE(m.Matches(0)); 2049dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen for (int i = 1; i <= num; ++i) { 2050dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(m.Matches(i)); 2051dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen } 2052dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_FALSE(m.Matches(num + 1)); 2053dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen} 2054dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 2055c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that AnyOf(m1, ..., mn) matches any value that matches at 2056c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// least one of the given matchers. 2057c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnyOfTest, MatchesWhenAnyMatches) { 2058c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 2059c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Le(1), Ge(3)); 2060c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(1)); 2061c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(4)); 2062c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(2)); 2063c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2064c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2)); 2065c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(-1)); 2066c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(1)); 2067c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(2)); 2068c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(0)); 2069c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2070c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3)); 2071c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(-1)); 2072c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(1)); 2073c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(2)); 2074c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(3)); 2075c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(0)); 2076c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2077c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Le(0), Gt(10), 3, 5, 7); 2078c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(0)); 2079c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(11)); 2080c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(3)); 2081c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(2)); 2082dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 2083dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // The following tests for varying number of sub-matchers. Due to the way 2084dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // the sub-matchers are handled it is enough to test every sub-matcher once 2085dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // with sub-matchers using the same matcher type. Varying matcher types are 2086dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen // checked for above. 2087dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(2, AnyOf(1, 2)); 2088dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(3, AnyOf(1, 2, 3)); 2089dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(4, AnyOf(1, 2, 3, 4)); 2090dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5)); 2091dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6)); 2092dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7)); 2093dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8)); 2094dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9)); 2095dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); 2096c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2097c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2098c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that AnyOf(m1, ..., mn) describes itself properly. 2099c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnyOfTest, CanDescribeSelf) { 2100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 2101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Le(1), Ge(3)); 2102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is <= 1) or (is >= 3)", 2103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 2104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2)); 2106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is < 0) or " 2107c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 1) or (is equal to 2))", 2108c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 2109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3)); 2111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is < 0) or " 2112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 1) or " 2113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 2) or " 2114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(is equal to 3)))", 2115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 2116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Le(0), Gt(10), 3, 5, 7); 2118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(is <= 0) or " 2119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is > 10) or " 2120c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 3) or " 2121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((is equal to 5) or " 2122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(is equal to 7))))", 2123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 2124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that AnyOf(m1, ..., mn) describes its negation properly. 2127c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnyOfTest, CanDescribeNegation) { 2128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 2129c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Le(1), Ge(3)); 2130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't <= 1) and (isn't >= 3)", 2131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 2132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2)); 2134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't < 0) and " 2135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 1) and (isn't equal to 2))", 2136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 2137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3)); 2139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't < 0) and " 2140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 1) and " 2141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 2) and " 2142c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(isn't equal to 3)))", 2143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 2144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(Le(0), Gt(10), 3, 5, 7); 2146c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(isn't <= 0) and " 2147c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't > 10) and " 2148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 3) and " 2149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "((isn't equal to 5) and " 2150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "(isn't equal to 7))))", 2151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 2152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that monomorphic matchers are safely cast by the AnyOf matcher. 2155c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) { 2156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // greater_than_5 and less_than_10 are monomorphic matchers. 2157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> greater_than_5 = Gt(5); 2158c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> less_than_10 = Lt(10); 2159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m = AnyOf(greater_than_5, less_than_10); 2161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10); 2162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m3 = AnyOf(greater_than_5, m2); 2163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2164c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests that EitherOf works when composing itself. 2165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10); 2166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10); 2167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2169c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AnyOfTest, ExplainsResult) { 2170c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m; 2171c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2172c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. Both matchers need to explain. The second 2173c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher doesn't give an explanation, so only the first matcher's 2174c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explanation is printed. 2175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(10), Lt(0)); 2176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 less than 10", Explain(m, 5)); 2177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. Both matchers need to explain. 2179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(10), GreaterThan(20)); 2180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20", 2181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, 5)); 2182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2183c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. All matchers need to explain. The second 2184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher doesn't given an explanation. 2185c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30)); 2186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30", 2187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, 5)); 2188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Failed match. All matchers need to explain. 2190c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30)); 2191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, " 2192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "and which is 25 less than 30", 2193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, 5)); 2194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. The first matcher, which succeeded, needs to 2196c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain. 2197c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(10), GreaterThan(20)); 2198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 more than 10", Explain(m, 15)); 2199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2200c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. The second matcher, which succeeded, needs to 2201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain. Since it doesn't given an explanation, nothing is 2202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // printed. 2203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(10), Lt(30)); 2204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 0)); 2205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Successful match. The second matcher, which succeeded, needs to 2207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explain. 2208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = AnyOf(GreaterThan(30), GreaterThan(20)); 2209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 5 more than 20", Explain(m, 25)); 2210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2211c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The following predicate function and predicate functor are for 2213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// testing the Truly(predicate) matcher. 2214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns non-zero if the input is positive. Note that the return 2216c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// type of this function is not bool. It's OK as Truly() accepts any 2217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// unary function or functor whose return type can be implicitly 2218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// converted to bool. 2219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochint IsPositive(double x) { 2220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return x > 0 ? 1 : 0; 2221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This functor returns true if the input is greater than the given 2224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// number. 2225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass IsGreaterThan { 2226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 2227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit IsGreaterThan(int threshold) : threshold_(threshold) {} 2228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool operator()(int n) const { return n > threshold_; } 2230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 2232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int threshold_; 2233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 2234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// For testing Truly(). 2236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochconst int foo = 0; 2237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This predicate returns true iff the argument references foo and has 2239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// a zero value. 2240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool ReferencesFooAndIsZero(const int& n) { 2241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return (&n == &foo) && (n == 0); 2242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2243c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Truly(predicate) matches what satisfies the given 2245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// predicate. 2246c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TrulyTest, MatchesWhatSatisfiesThePredicate) { 2247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m = Truly(IsPositive); 2248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(2.0)); 2249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(-1.5)); 2250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Truly(predicate_functor) works too. 2253c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TrulyTest, CanBeUsedWithFunctor) { 2254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = Truly(IsGreaterThan(5)); 2255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(6)); 2256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(4)); 2257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Truly(predicate) can describe itself properly. 2260c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TrulyTest, CanDescribeSelf) { 2261c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m = Truly(IsPositive); 2262c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("satisfies the given predicate", 2263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 2264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Truly(predicate) works when the matcher takes its 2267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// argument by reference. 2268c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TrulyTest, WorksForByRefArguments) { 2269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> m = Truly(ReferencesFooAndIsZero); 2270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(foo)); 2271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 2272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(n)); 2273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Matches(m) is a predicate satisfied by whatever that 2276c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// matches matcher m. 2277c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) { 2278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(Matches(Ge(0))(1)); 2279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(Matches(Eq('a'))('b')); 2280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Matches(m) works when the matcher takes its argument by 2283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// reference. 2284c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchesTest, WorksOnByRefArguments) { 2285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int m = 0, n = 0; 2286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n)); 2287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(Matches(Ref(m))(n)); 2288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2289c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a Matcher on non-reference type can be used in 2291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Matches(). 2292c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatchesTest, WorksWithMatcherOnNonRefType) { 2293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> eq5 = Eq(5); 2294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(Matches(eq5)(5)); 2295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(Matches(eq5)(2)); 2296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests Value(value, matcher). Since Value() is a simple wrapper for 2299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Matches(), which has been tested already, we don't spend a lot of 2300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// effort on testing Value(). 2301c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ValueTest, WorksWithPolymorphicMatcher) { 2302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(Value("hi", StartsWith("h"))); 2303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(Value(5, Gt(10))); 2304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2306c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ValueTest, WorksWithMonomorphicMatcher) { 2307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> is_zero = Eq(0); 2308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(Value(0, is_zero)); 2309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(Value('a', is_zero)); 2310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 0; 2312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const int&> ref_n = Ref(n); 2313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(Value(n, ref_n)); 2314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(Value(1, ref_n)); 2315c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2317c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) { 2318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener1; 2319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1)); 2320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("% 2 == 0", listener1.str()); 2321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener2; 2323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2)); 2324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", listener2.str()); 2325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2327c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) { 2328c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> is_even = PolymorphicIsEven(); 2329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener1; 2330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1)); 2331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("% 2 == 0", listener1.str()); 2332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2333c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const double&> is_zero = Eq(0); 2334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StringMatchResultListener listener2; 2335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2)); 2336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", listener2.str()); 2337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2339c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P(Really, inner_matcher, "") { 2340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return ExplainMatchResult(inner_matcher, arg, result_listener); 2341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2343c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, WorksInsideMATCHER) { 2344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(0, Really(Eq(0))); 2345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2347c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllArgsTest, WorksForTuple) { 2348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt())); 2349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt()))); 2350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2352c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllArgsTest, WorksForNonTuple) { 2353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(42, AllArgs(Gt(0))); 2354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT('a', Not(AllArgs(Eq('b')))); 2355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass AllArgsHelper { 2358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 2359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AllArgsHelper() {} 2360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MOCK_METHOD2(Helper, int(char x, int y)); 2362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 2364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper); 2365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 2366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2367c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(AllArgsTest, WorksInWithClause) { 2368c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AllArgsHelper helper; 2369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ON_CALL(helper, Helper(_, _)) 2370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch .With(AllArgs(Lt())) 2371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch .WillByDefault(Return(1)); 2372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_CALL(helper, Helper(_, _)); 2373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_CALL(helper, Helper(_, _)) 2374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch .With(AllArgs(Gt())) 2375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch .WillOnce(Return(2)); 2376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(1, helper.Helper('\1', 2)); 2378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(2, helper.Helper('a', 1)); 2379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value 2382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// matches the matcher. 2383c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) { 2384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_THAT(5, Ge(2)) << "This should succeed."; 2385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_THAT("Foo", EndsWith("oo")); 2386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too."; 2387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("Hello", StartsWith("Hell")); 2388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value 2391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// doesn't match the matcher. 2392c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) { 2393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(), 2394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // which cannot reference auto variables. 2395dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen static unsigned short n; // NOLINT 2396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 5; 2397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // VC++ prior to version 8.0 SP1 has a bug where it will not see any 2399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // functions declared in the namespace scope from within nested classes. 2400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all 2401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // namespace-level functions invoked inside them need to be explicitly 2402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // resolved. 2403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)), 2404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Value of: n\n" 2405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected: is > 10\n" 2406dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen " Actual: 5" + OfType("unsigned short")); 2407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 0; 2408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE( 2409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))), 2410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Value of: n\n" 2411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected: (is <= 7) and (is >= 5)\n" 2412dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen " Actual: 0" + OfType("unsigned short")); 2413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2414c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument 2416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// has a reference type. 2417c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherAssertionTest, WorksForByRefArguments) { 2418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We use a static variable here as EXPECT_FATAL_FAILURE() cannot 2419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // reference auto variables. 2420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static int n; 2421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 0; 2422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(n, AllOf(Le(7), Ref(n))); 2423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))), 2424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Value of: n\n" 2425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected: does not reference the variable @"); 2426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests the "Actual" part. 2427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))), 2428dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen "Actual: 0" + OfType("int") + ", which is located @"); 2429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if !GTEST_OS_SYMBIAN 2432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is 2433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// monomorphic. 2434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's 2436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Symbian compiler: it tries to compile 2437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// template<T, U> class MatcherCastImpl { ... 2438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// virtual bool MatchAndExplain(T x, ...) const { 2439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// return source_matcher_.MatchAndExplain(static_cast<U>(x), ...); 2440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// with U == string and T == const char* 2441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... ) 2442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the compiler silently crashes with no output. 2443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x) 2444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the code compiles but the converted string is bogus. 2445c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherAssertionTest, WorksForMonomorphicMatcher) { 2446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> starts_with_he = StartsWith("he"); 2447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_THAT("hello", starts_with_he); 2448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> ends_with_ok = EndsWith("ok"); 2450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_THAT("book", ends_with_ok); 2451dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen const string bad = "bad"; 2452dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad, ends_with_ok), 2453dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen "Value of: bad\n" 2454dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen "Expected: ends with \"ok\"\n" 2455dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen " Actual: \"bad\""); 2456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> is_greater_than_5 = Gt(5); 2457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5), 2458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Value of: 5\n" 2459c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected: is > 5\n" 2460dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen " Actual: 5" + OfType("int")); 2461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // !GTEST_OS_SYMBIAN 2463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests floating-point matchers. 2465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2466c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass FloatingPointTest : public testing::Test { 2467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 2468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef typename testing::internal::FloatingPoint<RawType> Floating; 2469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef typename Floating::Bits Bits; 2470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 2472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const size_t max_ulps = Floating::kMaxUlps; 2473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The bits that represent 0.0. 2475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Bits zero_bits = Floating(0).bits(); 2476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Makes some numbers close to 0.0. 2478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch close_to_positive_zero_ = Floating::ReinterpretBits(zero_bits + max_ulps/2); 2479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch close_to_negative_zero_ = -Floating::ReinterpretBits( 2480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch zero_bits + max_ulps - max_ulps/2); 2481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch further_from_negative_zero_ = -Floating::ReinterpretBits( 2482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch zero_bits + max_ulps + 1 - max_ulps/2); 2483c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The bits that represent 1.0. 2485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Bits one_bits = Floating(1).bits(); 2486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Makes some numbers close to 1.0. 2488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch close_to_one_ = Floating::ReinterpretBits(one_bits + max_ulps); 2489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch further_from_one_ = Floating::ReinterpretBits(one_bits + max_ulps + 1); 2490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // +infinity. 2492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch infinity_ = Floating::Infinity(); 2493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The bits that represent +infinity. 2495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Bits infinity_bits = Floating(infinity_).bits(); 2496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Makes some numbers close to infinity. 2498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch close_to_infinity_ = Floating::ReinterpretBits(infinity_bits - max_ulps); 2499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch further_from_infinity_ = Floating::ReinterpretBits( 2500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch infinity_bits - max_ulps - 1); 2501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Makes some NAN's. 2503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch nan1_ = Floating::ReinterpretBits(Floating::kExponentBitMask | 1); 2504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch nan2_ = Floating::ReinterpretBits(Floating::kExponentBitMask | 200); 2505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void TestSize() { 2508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 2509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // A battery of tests for FloatingEqMatcher::Matches. 2512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher_maker is a pointer to a function which creates a FloatingEqMatcher. 2513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void TestMatches( 2514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) { 2515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<RawType> m1 = matcher_maker(0.0); 2516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(-0.0)); 2517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(close_to_positive_zero_)); 2518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches(close_to_negative_zero_)); 2519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m1.Matches(1.0)); 2520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2521c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_); 2522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m2.Matches(further_from_negative_zero_)); 2523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<RawType> m3 = matcher_maker(1.0); 2525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m3.Matches(close_to_one_)); 2526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(further_from_one_)); 2527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above. 2529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m3.Matches(0.0)); 2530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<RawType> m4 = matcher_maker(-infinity_); 2532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m4.Matches(-close_to_infinity_)); 2533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<RawType> m5 = matcher_maker(infinity_); 2535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m5.Matches(close_to_infinity_)); 2536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // This is interesting as the representations of infinity_ and nan1_ 2538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // are only 1 DLP apart. 2539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m5.Matches(nan1_)); 2540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher_maker can produce a Matcher<const RawType&>, which is needed in 2542c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // some cases. 2543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const RawType&> m6 = matcher_maker(0.0); 2544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m6.Matches(-0.0)); 2545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m6.Matches(close_to_positive_zero_)); 2546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m6.Matches(1.0)); 2547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // matcher_maker can produce a Matcher<RawType&>, which is needed in some 2549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // cases. 2550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<RawType&> m7 = matcher_maker(0.0); 2551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch RawType x = 0.0; 2552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m7.Matches(x)); 2553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch x = 0.01f; 2554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m7.Matches(x)); 2555c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 2556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Pre-calculated numbers to be used by the tests. 2558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType close_to_positive_zero_; 2560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType close_to_negative_zero_; 2561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType further_from_negative_zero_; 2562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2563c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType close_to_one_; 2564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType further_from_one_; 2565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType infinity_; 2567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType close_to_infinity_; 2568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType further_from_infinity_; 2569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType nan1_; 2571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static RawType nan2_; 2572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 2573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2575c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::close_to_positive_zero_; 2576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2578c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::close_to_negative_zero_; 2579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2581c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::further_from_negative_zero_; 2582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2584c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::close_to_one_; 2585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2587c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::further_from_one_; 2588c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2590c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::infinity_; 2591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2593c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::close_to_infinity_; 2594c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2596c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::further_from_infinity_; 2597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2599c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::nan1_; 2600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename RawType> 2602c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochRawType FloatingPointTest<RawType>::nan2_; 2603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Instantiate FloatingPointTest for testing floats. 2605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef FloatingPointTest<float> FloatTest; 2606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2607c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) { 2608c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TestMatches(&FloatEq); 2609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2611c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) { 2612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TestMatches(&NanSensitiveFloatEq); 2613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2615c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FloatTest, FloatEqCannotMatchNaN) { 2616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // FloatEq never matches NaN. 2617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m = FloatEq(nan1_); 2618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(nan1_)); 2619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(nan2_)); 2620c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2622c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2623c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) { 2624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // NanSensitiveFloatEq will match NaN. 2625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m = NanSensitiveFloatEq(nan1_); 2626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(nan1_)); 2627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(nan2_)); 2628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2631c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FloatTest, FloatEqCanDescribeSelf) { 2632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m1 = FloatEq(2.0f); 2633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 2634c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 2635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m2 = FloatEq(0.5f); 2637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 2638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 2639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2640c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m3 = FloatEq(nan1_); 2641c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("never matches", Describe(m3)); 2642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is anything", DescribeNegation(m3)); 2643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2645c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) { 2646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m1 = NanSensitiveFloatEq(2.0f); 2647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 2648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 2649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m2 = NanSensitiveFloatEq(0.5f); 2651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 2652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 2653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<float> m3 = NanSensitiveFloatEq(nan1_); 2655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is NaN", Describe(m3)); 2656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't NaN", DescribeNegation(m3)); 2657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Instantiate FloatingPointTest for testing doubles. 2660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef FloatingPointTest<double> DoubleTest; 2661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2662c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) { 2663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TestMatches(&DoubleEq); 2664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2666c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) { 2667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TestMatches(&NanSensitiveDoubleEq); 2668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2670c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(DoubleTest, DoubleEqCannotMatchNaN) { 2671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // DoubleEq never matches NaN. 2672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m = DoubleEq(nan1_); 2673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(nan1_)); 2674c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(nan2_)); 2675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2678c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) { 2679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // NanSensitiveDoubleEq will match NaN. 2680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m = NanSensitiveDoubleEq(nan1_); 2681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(nan1_)); 2682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(nan2_)); 2683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(1.0)); 2684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2686c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(DoubleTest, DoubleEqCanDescribeSelf) { 2687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m1 = DoubleEq(2.0); 2688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 2689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 2690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m2 = DoubleEq(0.5); 2692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 2693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 2694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m3 = DoubleEq(nan1_); 2696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("never matches", Describe(m3)); 2697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is anything", DescribeNegation(m3)); 2698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2700c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) { 2701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m1 = NanSensitiveDoubleEq(2.0); 2702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 2", Describe(m1)); 2703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 2", DescribeNegation(m1)); 2704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m2 = NanSensitiveDoubleEq(0.5); 2706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is approximately 0.5", Describe(m2)); 2707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2)); 2708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double> m3 = NanSensitiveDoubleEq(nan1_); 2710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is NaN", Describe(m3)); 2711c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't NaN", DescribeNegation(m3)); 2712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2714c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, RawPointer) { 2715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int*> m = Pointee(Ge(0)); 2716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2717c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 1; 2718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&n)); 2719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = -1; 2720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&n)); 2721c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 2722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2724c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, RawPointerToConst) { 2725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const double*> m = Pointee(Ge(0)); 2726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double x = 1; 2728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&x)); 2729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch x = -1; 2730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&x)); 2731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 2732c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2734c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, ReferenceToConstRawPointer) { 2735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int* const &> m = Pointee(Ge(0)); 2736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 1; 2738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&n)); 2739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = -1; 2740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&n)); 2741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 2742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2744c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, ReferenceToNonConstRawPointer) { 2745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<double* &> m = Pointee(Ge(0)); 2746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double x = 1.0; 2748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double* p = &x; 2749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(p)); 2750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch x = -1; 2751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(p)); 2752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch p = NULL; 2753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(p)); 2754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2756c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, NeverMatchesNull) { 2757c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const char*> m = Pointee(_); 2758c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 2759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that we can write Pointee(value) instead of Pointee(Eq(value)). 2762c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, MatchesAgainstAValue) { 2763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int*> m = Pointee(5); 2764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 5; 2766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&n)); 2767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = -1; 2768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&n)); 2769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 2770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2771c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2772c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, CanDescribeSelf) { 2773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int*> m = Pointee(Gt(3)); 2774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("points to a value that is > 3", Describe(m)); 2775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("does not point to a value that is > 3", 2776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 2777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2779c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, CanExplainMatchResult) { 2780c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const string*> m = Pointee(StartsWith("Hi")); 2781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2782c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL))); 2783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2784dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen const Matcher<long*> m2 = Pointee(GreaterThan(1)); // NOLINT 2785dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen long n = 3; // NOLINT 2786dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1", 2787c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m2, &n)); 2788c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2790c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PointeeTest, AlwaysExplainsPointee) { 2791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int*> m = Pointee(0); 2792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n = 42; 2793dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which points to 42" + OfType("int"), Explain(m, &n)); 2794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2795c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// An uncopyable class. 2797c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass Uncopyable { 2798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 2799c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit Uncopyable(int a_value) : value_(a_value) {} 2800c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2801c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int value() const { return value_; } 2802c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 2803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int value_; 2804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable); 2805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 2806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns true iff x.value() is positive. 2808c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochbool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; } 2809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2810c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A user-defined struct for testing Field(). 2811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct AStruct { 2812c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct() : x(0), y(1.0), z(5), p(NULL) {} 2813c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct(const AStruct& rhs) 2814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch : x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {} 2815c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2816c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int x; // A non-const field. 2817c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const double y; // A const field. 2818c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Uncopyable z; // An uncopyable field. 2819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* p; // A pointer field. 2820c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2821c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 2822c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_ASSIGN_(AStruct); 2823c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 2824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2825c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A derived struct for testing Field(). 2826c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct DerivedStruct : public AStruct { 2827c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch char ch; 2828c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2829c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 2830c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_ASSIGN_(DerivedStruct); 2831c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 2832c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, ...) works when field is non-const. 2834c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForNonConstField) { 2835c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AStruct> m = Field(&AStruct::x, Ge(0)); 2836c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2838c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = -1; 2840c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2841c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2842c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2843c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, ...) works when field is const. 2844c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForConstField) { 2845c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2846c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2847c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0)); 2848c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2849c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Field(&AStruct::y, Le(0.0)); 2850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, ...) works when field is not copyable. 2854c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForUncopyableField) { 2855c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive)); 2858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Field(&AStruct::z, Not(Truly(ValueIsPositive))); 2860c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2861c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2862c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, ...) works when field is a pointer. 2864c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForPointerField) { 2865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Matching against NULL. 2866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL)); 2867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2869c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.p = "hi"; 2870c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2871c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2872c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Matching a pointer that is not NULL. 2873c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Field(&AStruct::p, StartsWith("hi")); 2874c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.p = "hill"; 2875c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2876c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.p = "hole"; 2877c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2878c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2879c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2880c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() works when the object is passed by reference. 2881c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForByRefArgument) { 2882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0)); 2883c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2885c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2886c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = -1; 2887c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2888c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2890c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, ...) works when the argument's type 2891c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// is a sub-type of Foo. 2892c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForArgumentOfSubType) { 2893c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Note that the matcher expects DerivedStruct but we say AStruct 2894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // inside Field(). 2895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0)); 2896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DerivedStruct d; 2898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(d)); 2899c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch d.x = -1; 2900c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(d)); 2901c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2903c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, m) works when field's type and m's 2904c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// argument type are compatible but not the same. 2905c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, WorksForCompatibleMatcherType) { 2906c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The field is an int, but the inner matcher expects a signed char. 2907c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, 2908c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<signed char>(Ge(0))); 2909c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2910c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2911c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 2912c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = -1; 2913c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 2914c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2915c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2916c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() can describe itself. 2917c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, CanDescribeSelf) { 2918c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0)); 2919c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2920c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given field is >= 0", Describe(m)); 2921c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m)); 2922c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2923c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() can explain the match result. 2925c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldTest, CanExplainMatchResult) { 2926c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0)); 2927c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = 1; 2930dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m, a)); 2931c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Field(&AStruct::x, GreaterThan(0)); 2933dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ( 2934dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen "whose given field is 1" + OfType("int") + ", which is 1 more than 0", 2935dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Explain(m, a)); 2936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2938c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() works when the argument is a pointer to const. 2939c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, WorksForPointerToConst) { 2940c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0)); 2941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&a)); 2944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = -1; 2945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&a)); 2946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2947c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2948c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() works when the argument is a pointer to non-const. 2949c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, WorksForPointerToNonConst) { 2950c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AStruct*> m = Field(&AStruct::x, Ge(0)); 2951c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2952c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2953c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&a)); 2954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = -1; 2955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&a)); 2956c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2957c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() works when the argument is a reference to a const pointer. 2959c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, WorksForReferenceToConstPointer) { 2960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0)); 2961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 2963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&a)); 2964c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = -1; 2965c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&a)); 2966c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2967c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() does not match the NULL pointer. 2969c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, DoesNotMatchNull) { 2970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, _); 2971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 2972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2973c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field(&Foo::field, ...) works when the argument's type 2975c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// is a sub-type of const Foo*. 2976c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, WorksForArgumentOfSubType) { 2977c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Note that the matcher expects DerivedStruct but we say AStruct 2978c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // inside Field(). 2979c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0)); 2980c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2981c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DerivedStruct d; 2982c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&d)); 2983c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch d.x = -1; 2984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&d)); 2985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() can describe itself when used to match a pointer. 2988c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, CanDescribeSelf) { 2989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0)); 2990c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2991c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given field is >= 0", Describe(m)); 2992c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m)); 2993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 2994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2995c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Field() can explain the result of matching a pointer. 2996c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FieldForPointerTest, CanExplainMatchResult) { 2997c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0)); 2998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 2999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AStruct a; 3000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.x = 1; 3001c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL))); 3002dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"), 3003dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Explain(m, &a)); 3004c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3005c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Field(&AStruct::x, GreaterThan(0)); 3006dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") + 3007dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen ", which is 1 more than 0", Explain(m, &a)); 3008c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3010c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A user-defined class for testing Property(). 3011c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass AClass { 3012c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 3013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass() : n_(0) {} 3014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // A getter that returns a non-reference. 3016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n() const { return n_; } 3017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3018c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void set_n(int new_n) { n_ = new_n; } 3019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3020c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // A getter that returns a reference to const. 3021c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const string& s() const { return s_; } 3022c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3023c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void set_s(const string& new_s) { s_ = new_s; } 3024c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3025c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // A getter that returns a reference to non-const. 3026c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double& x() const { return x_; } 3027c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 3028c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int n_; 3029c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch string s_; 3030c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3031c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static double x_; 3032c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3033c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3034c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochdouble AClass::x_ = 0.0; 3035c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3036c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A derived class for testing Property(). 3037c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass DerivedClass : public AClass { 3038c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 3039c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int k_; 3040c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3041c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3042c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, ...) works when property() 3043c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// returns a non-reference. 3044c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, WorksForNonReferenceProperty) { 3045c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, Ge(0)); 3046c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3047c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3048c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(1); 3049c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 3050c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3051c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(-1); 3052c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 3053c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3054c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3055c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, ...) works when property() 3056c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// returns a reference to const. 3057c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, WorksForReferenceToConstProperty) { 3058c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi")); 3059c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3060c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3061c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hill"); 3062c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 3063c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3064c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hole"); 3065c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 3066c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3067c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3068c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, ...) works when property() 3069c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// returns a reference to non-const. 3070c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, WorksForReferenceToNonConstProperty) { 3071c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double x = 0.0; 3072c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3073c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3074c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass&> m = Property(&AClass::x, Ref(x)); 3075c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 3076c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3077c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Property(&AClass::x, Not(Ref(x))); 3078c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 3079c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3080c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3081c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, ...) works when the argument is 3082c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// passed by value. 3083c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, WorksForByValueArgument) { 3084c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AClass> m = Property(&AClass::s, StartsWith("hi")); 3085c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3086c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3087c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hill"); 3088c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 3089c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3090c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hole"); 3091c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 3092c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3093c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3094c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, ...) works when the argument's 3095c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// type is a sub-type of Foo. 3096c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, WorksForArgumentOfSubType) { 3097c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The matcher expects a DerivedClass, but inside the Property() we 3098c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // say AClass. 3099c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0)); 3100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DerivedClass d; 3102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch d.set_n(1); 3103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(d)); 3104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch d.set_n(-1); 3106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(d)); 3107c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3108c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, m) works when property()'s type 3110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// and m's argument type are compatible but different. 3111c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, WorksForCompatibleMatcherType) { 3112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // n() returns an int but the inner matcher expects a signed char. 3113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, 3114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<signed char>(Ge(0))); 3115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(a)); 3118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(-1); 3119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(a)); 3120c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() can describe itself. 3123c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, CanDescribeSelf) { 3124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, Ge(0)); 3125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given property is >= 0", Describe(m)); 3127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given property isn't >= 0", 3128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 3129c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() can explain the match result. 3132c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyTest, CanExplainMatchResult) { 3133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass&> m = Property(&AClass::n, Ge(0)); 3134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(1); 3137dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m, a)); 3138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Property(&AClass::n, GreaterThan(0)); 3140dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ( 3141dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen "whose given property is 1" + OfType("int") + ", which is 1 more than 0", 3142dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Explain(m, a)); 3143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() works when the argument is a pointer to const. 3146c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, WorksForPointerToConst) { 3147c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass*> m = Property(&AClass::n, Ge(0)); 3148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(1); 3151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(-1); 3154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3155c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() works when the argument is a pointer to non-const. 3158c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, WorksForPointerToNonConst) { 3159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi")); 3160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hill"); 3163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3164c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hole"); 3166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() works when the argument is a reference to a 3170c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// const pointer. 3171c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, WorksForReferenceToConstPointer) { 3172c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi")); 3173c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3174c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hill"); 3176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&a)); 3177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_s("hole"); 3179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&a)); 3180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() does not match the NULL pointer. 3183c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) { 3184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass*> m = Property(&AClass::x, _); 3185c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(NULL)); 3186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property(&Foo::property, ...) works when the argument's 3189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// type is a sub-type of const Foo*. 3190c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, WorksForArgumentOfSubType) { 3191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The matcher expects a DerivedClass, but inside the Property() we 3192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // say AClass. 3193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0)); 3194c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DerivedClass d; 3196c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch d.set_n(1); 3197c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(&d)); 3198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch d.set_n(-1); 3200c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(&d)); 3201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() can describe itself when used to match a pointer. 3204c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, CanDescribeSelf) { 3205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass*> m = Property(&AClass::n, Ge(0)); 3206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given property is >= 0", Describe(m)); 3208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is an object whose given property isn't >= 0", 3209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 3210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3211c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Property() can explain the result of matching a pointer. 3213c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PropertyForPointerTest, CanExplainMatchResult) { 3214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const AClass*> m = Property(&AClass::n, Ge(0)); 3215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3216c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AClass a; 3217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a.set_n(1); 3218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL))); 3219dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ( 3220dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen "which points to an object whose given property is 1" + OfType("int"), 3221dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Explain(m, &a)); 3222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Property(&AClass::n, GreaterThan(0)); 3224dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which points to an object whose given property is 1" + 3225dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen OfType("int") + ", which is 1 more than 0", 3226dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Explain(m, &a)); 3227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests ResultOf. 3230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// function pointer. 3233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring IntToStringFunction(int input) { return input == 1 ? "foo" : "bar"; } 3234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3235c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForFunctionPointers) { 3236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo"))); 3237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(1)); 3239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(2)); 3240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf() can describe itself. 3243c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, CanDescribeItself) { 3244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo")); 3245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3246c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is mapped by the given callable to a value that " 3247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "is equal to \"foo\"", Describe(matcher)); 3248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is mapped by the given callable to a value that " 3249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "isn't equal to \"foo\"", DescribeNegation(matcher)); 3250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf() can explain the match result. 3253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochint IntFunction(int input) { return input == 42 ? 80 : 90; } 3254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3255c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, CanExplainMatchResult) { 3256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(&IntFunction, Ge(85)); 3257dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"), 3258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(matcher, 36)); 3259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch matcher = ResultOf(&IntFunction, GreaterThan(85)); 3261dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") + 3262dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen ", which is 5 more than 85", Explain(matcher, 36)); 3263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f(x) 3266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// returns a non-reference. 3267c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForNonReferenceResults) { 3268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(&IntFunction, Eq(80)); 3269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(42)); 3271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(36)); 3272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f(x) 3275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// returns a reference to non-const. 3276dc0f95d653279beabeb9817299e2902918ba123eKristian Monsendouble& DoubleFunction(double& input) { return input; } // NOLINT 3277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3278dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenUncopyable& RefUncopyableFunction(Uncopyable& obj) { // NOLINT 3279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return obj; 3280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3282c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForReferenceToNonConstResults) { 3283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double x = 3.14; 3284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch double x2 = x; 3285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x)); 3286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(x)); 3288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(x2)); 3289c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Test that ResultOf works with uncopyable objects 3291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Uncopyable obj(0); 3292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Uncopyable obj2(0); 3293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<Uncopyable&> matcher2 = 3294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ResultOf(&RefUncopyableFunction, Ref(obj)); 3295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher2.Matches(obj)); 3297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher2.Matches(obj2)); 3298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f(x) 3301c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// returns a reference to const. 3302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochconst string& StringFunction(const string& input) { return input; } 3303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3304c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForReferenceToConstResults) { 3305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch string s = "foo"; 3306c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch string s2 = s; 3307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s)); 3308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(s)); 3310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(s2)); 3311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, m) works when f(x) and m's 3314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// argument types are compatible but different. 3315c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForCompatibleMatcherTypes) { 3316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // IntFunction() returns int but the inner matcher expects a signed char. 3317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85))); 3318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(36)); 3320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(42)); 3321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the program aborts when ResultOf is passed 3324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// a NULL function pointer. 3325c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfDeathTest, DiesOnNullFunctionPointers) { 3326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_DEATH_IF_SUPPORTED( 3327dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen ResultOf(static_cast<string(*)(int dummy)>(NULL), Eq(string("foo"))), 3328c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "NULL function pointer is passed into ResultOf\\(\\)\\."); 3329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// function reference. 3333c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForFunctionReferences) { 3334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo")); 3335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(1)); 3336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(2)); 3337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// function object. 3341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct Functor : public ::std::unary_function<int, string> { 3342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch result_type operator()(argument_type input) const { 3343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return IntToStringFunction(input); 3344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 3345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3347c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForFunctors) { 3348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo"))); 3349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher.Matches(1)); 3351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher.Matches(2)); 3352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ResultOf(f, ...) compiles and works as expected when f is a 3355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// functor with more then one operator() defined. ResultOf() must work 3356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// for each defined operator(). 3357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct PolymorphicFunctor { 3358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef int result_type; 3359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int operator()(int n) { return n; } 3360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int operator()(const char* s) { return static_cast<int>(strlen(s)); } 3361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3363c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForPolymorphicFunctors) { 3364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5)); 3365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher_int.Matches(10)); 3367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher_int.Matches(2)); 3368c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5)); 3370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher_string.Matches("long string")); 3372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher_string.Matches("shrt")); 3373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochconst int* ReferencingFunction(const int& n) { return &n; } 3376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct ReferencingFunctor { 3378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef const int* result_type; 3379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch result_type operator()(const int& n) { return &n; } 3380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3382c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ResultOfTest, WorksForReferencingCallables) { 3383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int n = 1; 3384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int n2 = 1; 3385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n)); 3386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher2.Matches(n)); 3387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher2.Matches(n2)); 3388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n)); 3390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(matcher3.Matches(n)); 3391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(matcher3.Matches(n2)); 3392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass DivisibleByImpl { 3395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 3396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {} 3397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // For testing using ExplainMatchResultTo() with polymorphic matchers. 3399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch template <typename T> 3400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool MatchAndExplain(const T& n, MatchResultListener* listener) const { 3401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is " << (n % divider_) << " modulo " 3402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << divider_; 3403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return (n % divider_) == 0; 3404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 3405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 34063345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeTo(ostream* os) const { 3407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is divisible by " << divider_; 3408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 3409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 34103345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeNegationTo(ostream* os) const { 3411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is not divisible by " << divider_; 3412c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 3413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3414c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void set_divider(int a_divider) { divider_ = a_divider; } 3415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int divider() const { return divider_; } 3416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 3418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int divider_; 3419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3421c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochPolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) { 3422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return MakePolymorphicMatcher(DivisibleByImpl(n)); 3423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that when AllOf() fails, only the first failing matcher is 3426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// asked to explain why. 3427c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, AllOf_False_False) { 3428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3)); 3429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 1 modulo 4", Explain(m, 5)); 3430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that when AllOf() fails, only the first failing matcher is 3433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// asked to explain why. 3434c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, AllOf_False_True) { 3435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3)); 3436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 2 modulo 4", Explain(m, 6)); 3437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that when AllOf() fails, only the first failing matcher is 3440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// asked to explain why. 3441c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, AllOf_True_False) { 3442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3)); 3443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 2 modulo 3", Explain(m, 5)); 3444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3445c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that when AllOf() succeeds, all matchers are asked to explain 3447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// why. 3448c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, AllOf_True_True) { 3449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3)); 3450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6)); 3451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3453c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainMatchResultTest, AllOf_True_True_2) { 3454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = AllOf(Ge(2), Le(3)); 3455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 2)); 3456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3458c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExplainmatcherResultTest, MonomorphicMatcher) { 3459c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = GreaterThan(5); 3460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which is 1 more than 5", Explain(m, 6)); 3461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The following two tests verify that values without a public copy 3464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// ctor can be used as arguments to matchers like Eq(), Ge(), and etc 3465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// with the help of ByRef(). 3466c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass NotCopyable { 3468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 3469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit NotCopyable(int a_value) : value_(a_value) {} 3470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int value() const { return value_; } 3472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool operator==(const NotCopyable& rhs) const { 3474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return value() == rhs.value(); 3475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 3476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch bool operator>=(const NotCopyable& rhs) const { 3478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return value() >= rhs.value(); 3479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 3480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 3481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int value_; 3482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3483c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable); 3484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 3485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3486c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) { 3487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const NotCopyable const_value1(1); 3488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1)); 3489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const NotCopyable n1(1), n2(2); 3491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(n1)); 3492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(n2)); 3493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3495c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ByRefTest, AllowsNotCopyableValueInMatchers) { 3496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NotCopyable value2(2); 3497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<NotCopyable&> m = Ge(ByRef(value2)); 3498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NotCopyable n1(1), n2(2); 3500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(n1)); 3501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(n2)); 3502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_TYPED_TEST 3505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests ContainerEq with different container types, and 3506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// different element types. 3507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 3509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass ContainerEqTest : public testing::Test {}; 3510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef testing::Types< 35123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick set<int>, 35133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<size_t>, 35143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick multiset<size_t>, 35153345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick list<int> > 3516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ContainerEqTestTypes; 3517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3518c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_CASE(ContainerEqTest, ContainerEqTestTypes); 3519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the filled container is equal to itself. 3521c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(ContainerEqTest, EqualsSelf) { 3522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam my_set(vals, vals + 6); 3524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<TypeParam> m = ContainerEq(my_set); 3525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(my_set)); 3526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, my_set)); 3527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that missing values are reported. 3530c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(ContainerEqTest, ValueMissing) { 3531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {2, 1, 8, 5}; 3533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam my_set(vals, vals + 6); 3534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam test_set(test_vals, test_vals + 4); 3535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<TypeParam> m = ContainerEq(my_set); 3536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which doesn't have these expected elements: 3", 3538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_set)); 3539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that added values are reported. 3542c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(ContainerEqTest, ValueAdded) { 3543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {1, 2, 3, 5, 8, 46}; 3545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam my_set(vals, vals + 6); 3546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam test_set(test_vals, test_vals + 6); 3547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const TypeParam&> m = ContainerEq(my_set); 3548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set)); 3550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that added and missing values are reported together. 3553c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) { 3554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3555c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {1, 2, 3, 8, 46}; 3556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam my_set(vals, vals + 6); 3557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam test_set(test_vals, test_vals + 5); 3558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<TypeParam> m = ContainerEq(my_set); 3559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which has these unexpected elements: 46,\n" 3561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "and doesn't have these expected elements: 5", 3562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_set)); 3563c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests duplicated value -- expect no explanation. 3566c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(ContainerEqTest, DuplicateDifference) { 3567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {1, 2, 3, 5, 8}; 3569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam my_set(vals, vals + 6); 3570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TypeParam test_set(test_vals, test_vals + 5); 3571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const TypeParam&> m = ContainerEq(my_set); 3572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Depending on the container, match may be true or false 3573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // But in any case there should be no explanation. 3574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, test_set)); 3575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_TYPED_TEST 3577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that mutliple missing values are reported. 3579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Using just vector here, so order is predicatble. 3580c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, MultipleValuesMissing) { 3581c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {2, 1, 5}; 35833345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> my_set(vals, vals + 6); 35843345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> test_set(test_vals, test_vals + 3); 35853345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<vector<int> > m = ContainerEq(my_set); 3586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3587c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which doesn't have these expected elements: 3, 8", 3588c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_set)); 3589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that added values are reported. 3592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Using just vector here, so order is predicatble. 3593c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, MultipleValuesAdded) { 3594c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46}; 35963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick list<size_t> my_set(vals, vals + 6); 35973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick list<size_t> test_set(test_vals, test_vals + 7); 35983345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<const list<size_t>&> m = ContainerEq(my_set); 3599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which has these unexpected elements: 92, 46", 3601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_set)); 3602c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that added and missing values are reported together. 3605c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) { 3606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3607c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {1, 2, 3, 92, 46}; 36083345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick list<size_t> my_set(vals, vals + 6); 36093345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick list<size_t> test_set(test_vals, test_vals + 5); 36103345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<const list<size_t> > m = ContainerEq(my_set); 3611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which has these unexpected elements: 92, 46,\n" 3613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "and doesn't have these expected elements: 5, 8", 3614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_set)); 3615c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests to see that duplicate elements are detected, 3618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// but (as above) not reported in the explanation. 3619c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) { 3620c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int vals[] = {1, 1, 2, 3, 5, 8}; 3621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int test_vals[] = {1, 2, 3, 5, 8}; 36223345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> my_set(vals, vals + 6); 36233345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> test_set(test_vals, test_vals + 5); 36243345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<vector<int> > m = ContainerEq(my_set); 3625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(my_set)); 3626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_set)); 3627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // There is nothing to report when both sets contain all the same values. 3628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, test_set)); 3629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that ContainerEq works for non-trivial associative containers, 3632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// like maps. 3633c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, WorksForMaps) { 36343345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick map<int, std::string> my_map; 3635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch my_map[0] = "a"; 3636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch my_map[1] = "b"; 3637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 36383345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick map<int, std::string> test_map; 3639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_map[0] = "aa"; 3640c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_map[1] = "b"; 3641c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 36423345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<const map<int, std::string>&> m = ContainerEq(my_map); 3643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(my_map)); 3644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_map)); 3645c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n" 3647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "and doesn't have these expected elements: (0, \"a\")", 3648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_map)); 3649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3651c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, WorksForNativeArray) { 3652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a1[] = { 1, 2, 3 }; 3653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a2[] = { 1, 2, 3 }; 3654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int b[] = { 1, 2, 4 }; 3655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, ContainerEq(a2)); 3657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, Not(ContainerEq(b))); 3658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3660c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) { 3661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char a1[][3] = { "hi", "lo" }; 3662c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char a2[][3] = { "hi", "lo" }; 3663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char b[][3] = { "lo", "hi" }; 3664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests using ContainerEq() in the first dimension. 3666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, ContainerEq(a2)); 3667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, Not(ContainerEq(b))); 3668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tests using ContainerEq() in the second dimension. 3670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1]))); 3671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1]))); 3672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3674c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) { 3675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a1[] = { 1, 2, 3 }; 3676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a2[] = { 1, 2, 3 }; 3677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int b[] = { 1, 2, 3, 4 }; 3678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int* const p1 = a1; 3680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2)); 3681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b))); 3682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int c[] = { 1, 3, 2 }; 3684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c))); 3685c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3687c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainerEqExtraTest, CopiesNativeArrayParameter) { 3688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch std::string a1[][3] = { 3689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { "hi", "hello", "ciao" }, 3690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { "bye", "see you", "ciao" } 3691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }; 3692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch std::string a2[][3] = { 3694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { "hi", "hello", "ciao" }, 3695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { "bye", "see you", "ciao" } 3696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }; 3697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2); 3699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, m); 3700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch a2[0][0] = "ha"; 3702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a1, m); 3703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3705dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// Tests IsReadableTypeName(). 3706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3707dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenTEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) { 3708dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("int")); 3709dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("const unsigned char*")); 3710dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>")); 3711dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)")); 3712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3714dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenTEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) { 3715dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName")); 3716dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]")); 3717dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass")); 3718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3720dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenTEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) { 3721dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_FALSE( 3722dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen IsReadableTypeName("basic_string<char, std::char_traits<char> >")); 3723dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >")); 3724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3726dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenTEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) { 3727dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)")); 3728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests JoinAsTuple(). 3731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3732c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(JoinAsTupleTest, JoinsEmptyTuple) { 3733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", JoinAsTuple(Strings())); 3734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3736c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(JoinAsTupleTest, JoinsOneTuple) { 3737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* fields[] = { "1" }; 3738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1))); 3739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3741c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(JoinAsTupleTest, JoinsTwoTuple) { 3742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* fields[] = { "1", "a" }; 3743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2))); 3744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3746c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(JoinAsTupleTest, JoinsTenTuple) { 3747c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* fields[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" }; 3748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)", 3749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch JoinAsTuple(Strings(fields, fields + 10))); 3750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests FormatMatcherDescription(). 3753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3754c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) { 3755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is even", 3756dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen FormatMatcherDescription(false, "IsEven", Strings())); 3757dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("not (is even)", 3758dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen FormatMatcherDescription(true, "IsEven", Strings())); 3759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* params[] = { "5" }; 3761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("equals 5", 3762dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen FormatMatcherDescription(false, "Equals", 3763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Strings(params, params + 1))); 3764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* params2[] = { "5", "8" }; 3766c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is in range (5, 8)", 3767dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen FormatMatcherDescription(false, "IsInRange", 3768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Strings(params2, params2 + 2))); 3769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3771c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests PolymorphicMatcher::mutable_impl(). 3772c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PolymorphicMatcherTest, CanAccessMutableImpl) { 3773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42)); 3774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DivisibleByImpl& impl = m.mutable_impl(); 3775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(42, impl.divider()); 3776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch impl.set_divider(0); 3778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(0, m.mutable_impl().divider()); 3779c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3780c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests PolymorphicMatcher::impl(). 3782c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PolymorphicMatcherTest, CanAccessImpl) { 3783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42)); 3784c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const DivisibleByImpl& impl = m.impl(); 3785c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(42, impl.divider()); 3786c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3787c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3788c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherTupleTest, ExplainsMatchFailure) { 3789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss1; 3790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)), 3791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch make_tuple('a', 10), &ss1); 3792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", ss1.str()); // Successful match. 3793c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss2; 3795c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))), 3796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch make_tuple(2, 'b'), &ss2); 3797c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(" Expected arg #0: is > 5\n" 3798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch " Actual: 2, which is 3 less than 5\n" 3799dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen " Expected arg #1: is equal to 'a' (97, 0x61)\n" 3800dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen " Actual: 'b' (98, 0x62)\n", 3801c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ss2.str()); // Failed match where both arguments need explanation. 3802c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss3; 3804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))), 3805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch make_tuple(2, 'a'), &ss3); 3806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(" Expected arg #0: is > 5\n" 3807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch " Actual: 2, which is 3 less than 5\n", 3808c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ss3.str()); // Failed match where only one argument needs 3809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // explanation. 3810c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 3811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 38123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick// Tests Each(). 38133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38143345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(EachTest, ExplainsMatchResultCorrectly) { 38153345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick set<int> a; // empty 38163345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38173345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Matcher<set<int> > m = Each(2); 38183345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("", Explain(m, a)); 38193345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 3820dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen Matcher<const int(&)[1]> n = Each(1); // NOLINT 38213345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38223345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int b[1] = { 1 }; 38233345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("", Explain(n, b)); 38243345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38253345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick n = Each(3); 38263345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("whose element #0 doesn't match", Explain(n, b)); 38273345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38283345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick a.insert(1); 38293345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick a.insert(2); 38303345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick a.insert(3); 38313345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick m = Each(GreaterThan(0)); 38323345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("", Explain(m, a)); 38333345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38343345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick m = Each(GreaterThan(10)); 38353345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10", 38363345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Explain(m, a)); 38373345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 38383345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38393345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(EachTest, DescribesItselfCorrectly) { 38403345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Matcher<vector<int> > m = Each(1); 38413345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("only contains elements that is equal to 1", Describe(m)); 38423345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38433345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Matcher<vector<int> > m2 = Not(m); 38443345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2)); 38453345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 38463345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38473345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(EachTest, MatchesVectorWhenAllElementsMatch) { 38483345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> some_vector; 38493345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(some_vector, Each(1)); 38503345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick some_vector.push_back(3); 38513345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(some_vector, Not(Each(1))); 38523345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(some_vector, Each(3)); 38533345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick some_vector.push_back(1); 38543345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick some_vector.push_back(2); 38553345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(some_vector, Not(Each(3))); 38563345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(some_vector, Each(Lt(3.5))); 38573345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38583345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<string> another_vector; 38593345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_vector.push_back("fee"); 38603345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_vector, Each(string("fee"))); 38613345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_vector.push_back("fie"); 38623345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_vector.push_back("foe"); 38633345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_vector.push_back("fum"); 38643345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_vector, Not(Each(string("fee")))); 38653345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 38663345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38673345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(EachTest, MatchesMapWhenAllElementsMatch) { 38683345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick map<const char*, int> my_map; 38693345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const char* bar = "a string"; 38703345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick my_map[bar] = 2; 38713345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(my_map, Each(make_pair(bar, 2))); 38723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38733345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick map<string, int> another_map; 38743345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1))); 38753345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_map["fee"] = 1; 38763345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1))); 38773345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_map["fie"] = 2; 38783345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_map["foe"] = 3; 38793345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick another_map["fum"] = 4; 38803345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_map, Not(Each(make_pair(string("fee"), 1)))); 38813345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_map, Not(Each(make_pair(string("fum"), 1)))); 38823345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(another_map, Each(Pair(_, Gt(0)))); 38833345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 38843345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38853345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(EachTest, AcceptsMatcher) { 38863345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int a[] = { 1, 2, 3 }; 38873345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(a, Each(Gt(0))); 38883345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(a, Not(Each(Gt(1)))); 38893345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 38903345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38913345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(EachTest, WorksForNativeArrayAsTuple) { 38923345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int a[] = { 1, 2 }; 38933345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int* const pointer = a; 38943345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(make_tuple(pointer, 2), Each(Gt(0))); 38953345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(make_tuple(pointer, 2), Not(Each(Gt(1)))); 38963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 38973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 38983345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick// For testing Pointwise(). 38993345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickclass IsHalfOfMatcher { 39003345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick public: 39013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick template <typename T1, typename T2> 39023345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick bool MatchAndExplain(const tuple<T1, T2>& a_pair, 39033345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick MatchResultListener* listener) const { 39043345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick if (get<0>(a_pair) == get<1>(a_pair)/2) { 39053345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick *listener << "where the second is " << get<1>(a_pair); 39063345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return true; 39073345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } else { 39083345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick *listener << "where the second/2 is " << get<1>(a_pair)/2; 39093345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return false; 39103345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 39113345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 39123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeTo(ostream* os) const { 39143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick *os << "are a pair where the first is half of the second"; 39153345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 39163345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39173345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick void DescribeNegationTo(ostream* os) const { 39183345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick *os << "are a pair where the first isn't half of the second"; 39193345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick } 39203345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick}; 39213345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39223345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickPolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() { 39233345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick return MakePolymorphicMatcher(IsHalfOfMatcher()); 39243345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39253345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39263345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, DescribesSelf) { 39273345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> rhs; 39283345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(1); 39293345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(2); 39303345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(3); 39313345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs); 39323345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("contains 3 values, where each value and its corresponding value " 39333345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "in { 1, 2, 3 } are a pair where the first is half of the second", 39343345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Describe(m)); 39353345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some " 39363345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "index i where x and the i-th value of { 1, 2, 3 } are a pair " 39373345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "where the first isn't half of the second", 39383345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick DescribeNegation(m)); 39393345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39403345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39413345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, MakesCopyOfRhs) { 39423345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick list<signed char> rhs; 39433345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(2); 39443345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(4); 39453345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39463345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick int lhs[] = { 1, 2 }; 39473345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs); 39483345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, m); 39493345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39503345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // Changing rhs now shouldn't affect m, which made a copy of rhs. 39513345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(6); 39523345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, m); 39533345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39543345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39553345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, WorksForLhsNativeArray) { 39563345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int lhs[] = { 1, 2, 3 }; 39573345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> rhs; 39583345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(2); 39593345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(4); 39603345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick rhs.push_back(6); 39613345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Pointwise(Lt(), rhs)); 39623345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs))); 39633345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39643345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39653345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, WorksForRhsNativeArray) { 39663345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int rhs[] = { 1, 2, 3 }; 39673345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick vector<int> lhs; 39683345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick lhs.push_back(2); 39693345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick lhs.push_back(4); 39703345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick lhs.push_back(6); 39713345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Pointwise(Gt(), rhs)); 39723345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Not(Pointwise(Lt(), rhs))); 39733345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39743345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39753345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, RejectsWrongSize) { 39763345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const double lhs[2] = { 1, 2 }; 39773345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int rhs[1] = { 0 }; 39783345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs))); 39793345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("which contains 2 values", 39803345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Explain(Pointwise(Gt(), rhs), lhs)); 39813345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39823345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int rhs2[3] = { 0, 1, 2 }; 39833345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2))); 39843345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39853345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39863345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, RejectsWrongContent) { 39873345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const double lhs[3] = { 1, 2, 3 }; 39883345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int rhs[3] = { 2, 6, 4 }; 39893345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs))); 39903345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, " 39913345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "where the second/2 is 3", 39923345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick Explain(Pointwise(IsHalfOf(), rhs), lhs)); 39933345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 39943345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 39953345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, AcceptsCorrectContent) { 39963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const double lhs[3] = { 1, 2, 3 }; 39973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int rhs[3] = { 2, 4, 6 }; 39983345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Pointwise(IsHalfOf(), rhs)); 39993345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs), lhs)); 40003345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 40013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 40023345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST(PointwiseTest, AllowsMonomorphicInnerMatcher) { 40033345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const double lhs[3] = { 1, 2, 3 }; 40043345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const int rhs[3] = { 2, 4, 6 }; 40053345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf(); 40063345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Pointwise(m1, rhs)); 40073345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("", Explain(Pointwise(m1, rhs), lhs)); 40083345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 40093345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // This type works as a tuple<const double&, const int&> can be 40103345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick // implicitly cast to tuple<double, int>. 40113345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick const Matcher<tuple<double, int> > m2 = IsHalfOf(); 40123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_THAT(lhs, Pointwise(m2, rhs)); 40133345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("", Explain(Pointwise(m2, rhs), lhs)); 40143345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 40153345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 4016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace gmock_matchers_test 4017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace testing 4018