1c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Copyright 2008, 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// Google Mock - a framework for writing C++ mock classes. 31c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 32c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This file tests the built-in matchers generated by a script. 33c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 34dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gmock/gmock-generated-matchers.h" 35c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 36c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <list> 37c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <map> 38c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <set> 39c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <sstream> 40c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <string> 41c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <utility> 42c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <vector> 43c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 44dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gmock/gmock.h" 45dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gtest/gtest.h" 46dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen#include "gtest/gtest-spi.h" 47c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 48c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace { 49c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 50c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::list; 51c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::map; 52c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::pair; 53c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::set; 54c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::stringstream; 55c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::vector; 56c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::tr1::get; 57c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::tr1::make_tuple; 58c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing std::tr1::tuple; 59c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::_; 60c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Args; 61c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Contains; 62c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ElementsAre; 63c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ElementsAreArray; 64c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Eq; 65c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Ge; 66c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Gt; 67c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Lt; 68c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MakeMatcher; 69c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Matcher; 70c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MatcherInterface; 71c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::MatchResultListener; 72c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Ne; 73c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Not; 74c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Pointee; 75dc0f95d653279beabeb9817299e2902918ba123eKristian Monsenusing testing::PrintToString; 76c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Ref; 77c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StaticAssertTypeEq; 78c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::StrEq; 79c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::Value; 80c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::string; 81c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 82c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns the description of the given matcher. 83c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 84c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring Describe(const Matcher<T>& m) { 85c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss; 86c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m.DescribeTo(&ss); 87c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return ss.str(); 88c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 89c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 90c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns the description of the negation of the given matcher. 91c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 92c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring DescribeNegation(const Matcher<T>& m) { 93c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss; 94c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m.DescribeNegationTo(&ss); 95c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return ss.str(); 96c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 97c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 98c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Returns the reason why x matches, or doesn't match, m. 99c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename MatcherType, typename Value> 100c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstring Explain(const MatcherType& m, const Value& x) { 101c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch stringstream ss; 102c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m.ExplainMatchResultTo(x, &ss); 103c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return ss.str(); 104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 105c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests Args<k0, ..., kn>(m). 107c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 108c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsZeroTemplateArg) { 109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const tuple<int, bool> t(5, true); 110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Args<>(Eq(tuple<>()))); 111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Not(Args<>(Ne(tuple<>())))); 112c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 114c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsOneTemplateArg) { 115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const tuple<int, bool> t(5, true); 116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Args<0>(Eq(make_tuple(5)))); 117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Args<1>(Eq(make_tuple(true)))); 118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Not(Args<1>(Eq(make_tuple(false))))); 119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 120c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 121c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsTwoTemplateArgs) { 122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const tuple<short, int, long> t(4, 5, 6L); // NOLINT 123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, (Args<0, 1>(Lt()))); 125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, (Args<1, 2>(Lt()))); 126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Not(Args<0, 2>(Gt()))); 127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 129c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsRepeatedTemplateArgs) { 130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const tuple<short, int, long> t(4, 5, 6L); // NOLINT 131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, (Args<0, 0>(Eq()))); 132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Not(Args<1, 1>(Ne()))); 133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 135c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsDecreasingTemplateArgs) { 136c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const tuple<short, int, long> t(4, 5, 6L); // NOLINT 137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, (Args<2, 0>(Gt()))); 138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, Not(Args<2, 1>(Lt()))); 139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The MATCHER*() macros trigger warning C4100 (unreferenced formal 142c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in 143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the macro definition, as the warnings are generated when the macro 144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// is expanded and macro expansion cannot contain #pragma. Therefore 145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// we suppress them here. 146c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#ifdef _MSC_VER 147ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(push) 148ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(disable:4100) 149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif 150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 151c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(SumIsZero, "") { 152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return get<0>(arg) + get<1>(arg) + get<2>(arg) == 0; 153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 155c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) { 156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero()))); 157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero()))); 158c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 160c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, CanBeNested) { 161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const tuple<short, int, long, int> t(4, 5, 6L, 6); // NOLINT 162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq())))); 163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt())))); 164c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 166c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, CanMatchTupleByValue) { 167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef tuple<char, int, int> Tuple3; 168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<Tuple3> m = Args<1, 2>(Lt()); 169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2))); 170c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2))); 171c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 172c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 173c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, CanMatchTupleByReference) { 174c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch typedef tuple<char, char, int> Tuple3; 175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const Tuple3&> m = Args<0, 1>(Lt()); 176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2))); 177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2))); 178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Validates that arg is printed as str. 181c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P(PrintsAs, str, "") { 182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return testing::PrintToString(arg) == str; 183c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 185c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, AcceptsTenTemplateArgs) { 186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9), 187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>( 188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)")))); 189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9), 190c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>( 191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)")))); 192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 194c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, DescirbesSelfCorrectly) { 195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<tuple<int, bool, char> > m = Args<2, 0>(Lt()); 1963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are a tuple whose fields (#2, #0) are a pair where " 1973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "the first < the second", 198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 200c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 201c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, DescirbesNestedArgsCorrectly) { 202c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const tuple<int, bool, char, int>&> m = 203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Args<0, 2, 3>(Args<2, 0>(Lt())); 204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("are a tuple whose fields (#0, #2, #3) are a tuple " 2053345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "whose fields (#2, #0) are a pair where the first < the second", 206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 209c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, DescribesNegationCorrectly) { 210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<tuple<int, char> > m = Args<1, 0>(Gt()); 2113345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ("are a tuple whose fields (#1, #0) aren't a pair " 2123345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick "where the first > the second", 213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DescribeNegation(m)); 214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 216c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) { 217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<tuple<bool, int, int> > m = Args<1, 2>(Eq()); 218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose fields (#1, #2) are (42, 42)", 219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_tuple(false, 42, 42))); 220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose fields (#1, #2) are (42, 43)", 221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_tuple(false, 42, 43))); 222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// For testing Args<>'s explanation. 225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass LessThanMatcher : public MatcherInterface<tuple<char, int> > { 226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void DescribeTo(::std::ostream* os) const {} 228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual bool MatchAndExplain(tuple<char, int> value, 230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MatchResultListener* listener) const { 231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int diff = get<0>(value) - get<1>(value); 232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (diff > 0) { 233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "where the first value is " << diff 234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << " more than the second"; 235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return diff < 0; 237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 240c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMatcher<tuple<char, int> > LessThan() { 241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return MakeMatcher(new LessThanMatcher); 242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 243c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 244c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) { 245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<tuple<char, int, int> > m = Args<0, 2>(LessThan()); 246dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("whose fields (#0, #2) are ('a' (97, 0x61), 42), " 247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "where the first value is 55 more than the second", 248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_tuple('a', 42, 42))); 249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)", 250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, make_tuple('\0', 42, 43))); 251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// For testing ExplainMatchResultTo(). 254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass GreaterThanMatcher : public MatcherInterface<int> { 255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {} 257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void DescribeTo(::std::ostream* os) const { 259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *os << "is greater than " << rhs_; 260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 261c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 262c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual bool MatchAndExplain(int lhs, 263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MatchResultListener* listener) const { 264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int diff = lhs - rhs_; 265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (diff > 0) { 266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is " << diff << " more than " << rhs_; 267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else if (diff == 0) { 268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is the same as " << rhs_; 269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *listener << "which is " << -diff << " less than " << rhs_; 271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return lhs > rhs_; 274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 276c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int rhs_; 278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 280c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMatcher<int> GreaterThan(int n) { 281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return MakeMatcher(new GreaterThanMatcher(n)); 282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests for ElementsAre(). 285c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Evaluates to the number of elements in 'array'. 287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#define GMOCK_ARRAY_SIZE_(array) (sizeof(array)/sizeof(array[0])) 288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 289c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanDescribeExpectingNoElement) { 290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const vector<int>&> m = ElementsAre(); 291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is empty", Describe(m)); 292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 294c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanDescribeExpectingOneElement) { 295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<int> > m = ElementsAre(Gt(5)); 296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has 1 element that is > 5", Describe(m)); 297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 299c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanDescribeExpectingManyElements) { 300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<list<string> > m = ElementsAre(StrEq("one"), "two"); 301c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("has 2 elements where\n" 302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "element #0 is equal to \"one\",\n" 303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "element #1 is equal to \"two\"", Describe(m)); 304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 306c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) { 307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<int> > m = ElementsAre(); 308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("isn't empty", DescribeNegation(m)); 309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 310c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 311c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) { 312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const list<int>& > m = ElementsAre(Gt(5)); 313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("doesn't have 1 element, or\n" 314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "element #0 isn't > 5", DescribeNegation(m)); 315c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 317c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) { 318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const list<string>& > m = ElementsAre("one", "two"); 319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("doesn't have 2 elements, or\n" 320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "element #0 isn't equal to \"one\", or\n" 321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "element #1 isn't equal to \"two\"", DescribeNegation(m)); 322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 324c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, DoesNotExplainTrivialMatch) { 325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const list<int>& > m = ElementsAre(1, Ne(2)); 326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 327c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch list<int> test_list; 328c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_list.push_back(1); 329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_list.push_back(3); 330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, test_list)); // No need to explain anything. 331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 333c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, ExplainsNonTrivialMatch) { 334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const vector<int>& > m = 335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ElementsAre(GreaterThan(1), 0, GreaterThan(2)); 336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a[] = { 10, 0, 100 }; 338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); 339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n" 340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "and whose element #2 matches, which is 98 more than 2", 341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, test_vector)); 342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 344c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanExplainMismatchWrongSize) { 345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const list<int>& > m = ElementsAre(1, 3); 346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch list<int> test_list; 348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // No need to explain when the container is empty. 349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, test_list)); 350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_list.push_back(1); 352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("which has 1 element", Explain(m, test_list)); 353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 354c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 355c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, CanExplainMismatchRightSize) { 356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const vector<int>& > m = ElementsAre(1, GreaterThan(5)); 357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> v; 359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch v.push_back(2); 360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch v.push_back(1); 361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose element #0 doesn't match", Explain(m, v)); 362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch v[0] = 1; 364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5", 365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Explain(m, v)); 366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 368c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesOneElementVector) { 369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector; 370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("test string"); 371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAre(StrEq("test string"))); 373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 375c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesOneElementList) { 376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch list<string> test_list; 377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_list.push_back("test string"); 378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_list, ElementsAre("test string")); 380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 382c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesThreeElementVector) { 383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector; 384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("one"); 385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("two"); 386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("three"); 387c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAre("one", StrEq("two"), _)); 389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 391c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesOneElementEqMatcher) { 392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector; 393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back(4); 394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAre(Eq(4))); 396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 398c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesOneElementAnyMatcher) { 399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector; 400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back(4); 401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAre(_)); 403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 405c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesOneElementValue) { 406c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector; 407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back(4); 408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAre(4)); 410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 412c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) { 413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector; 414c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back(1); 415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back(2); 416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back(3); 417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAre(1, Eq(2), _)); 419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 421c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, MatchesTenElementVector) { 422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); 424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, 426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The element list can contain values and/or matchers 427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // of different types. 428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ElementsAre(0, Ge(0), _, 3, 4, Ne(2), Eq(6), 7, 8, _)); 429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 431c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, DoesNotMatchWrongSize) { 432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector; 433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("test string"); 434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("test string"); 435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<string> > m = ElementsAre(StrEq("test string")); 437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_vector)); 438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 439c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 440c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, DoesNotMatchWrongValue) { 441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector; 442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("other string"); 443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 444c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<string> > m = ElementsAre(StrEq("test string")); 445c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_vector)); 446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 448c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, DoesNotMatchWrongOrder) { 449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector; 450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("one"); 451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("three"); 452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("two"); 453c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<string> > m = ElementsAre( 455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StrEq("one"), StrEq("two"), StrEq("three")); 456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(test_vector)); 457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 459c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, WorksForNestedContainer) { 460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* strings[] = { 461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Hi", 462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "world" 463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }; 464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<list<char> > nested; 466c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (size_t i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) { 467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i]))); 468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(nested, ElementsAre(ElementsAre('H', Ne('e')), 471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ElementsAre('w', 'o', _, _, 'd'))); 472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(nested, Not(ElementsAre(ElementsAre('H', 'e'), 473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ElementsAre('w', 'o', _, _, 'd')))); 474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 476c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, WorksWithByRefElementMatchers) { 477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a[] = { 0, 1, 2 }; 478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> v(a, a + GMOCK_ARRAY_SIZE_(a)); 479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(v, ElementsAre(Ref(v[0]), Ref(v[1]), Ref(v[2]))); 481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(v, Not(ElementsAre(Ref(v[0]), Ref(v[1]), Ref(a[2])))); 482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 483c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 484c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) { 485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a[] = { 0, 1, 2 }; 486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> v(a, a + GMOCK_ARRAY_SIZE_(a)); 487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(&v, Pointee(ElementsAre(0, 1, _))); 489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(&v, Not(Pointee(ElementsAre(0, _, 3)))); 490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 492c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) { 493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int array[] = { 0, 1, 2 }; 494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(array, ElementsAre(0, 1, _)); 495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(array, Not(ElementsAre(1, _, _))); 496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(array, Not(ElementsAre(0, _))); 497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass NativeArrayPassedAsPointerAndSize { 500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NativeArrayPassedAsPointerAndSize() {} 502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch MOCK_METHOD2(Helper, void(int* array, int size)); 504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize); 507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 509c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) { 510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int array[] = { 0, 1 }; 511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::tr1::tuple<int*, size_t> array_as_tuple(array, 2); 512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(array_as_tuple, ElementsAre(0, 1)); 513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(array_as_tuple, Not(ElementsAre(0))); 514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NativeArrayPassedAsPointerAndSize helper; 516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_CALL(helper, Helper(_, _)) 517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch .With(ElementsAre(0, 1)); 518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch helper.Helper(array, 2); 519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 520c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 521c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) { 522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char a2[][3] = { "hi", "lo" }; 523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a2, ElementsAre(ElementsAre('h', 'i', '\0'), 524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ElementsAre('l', 'o', '\0'))); 525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a2, ElementsAre(StrEq("hi"), StrEq("lo"))); 526c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a2, ElementsAre(Not(ElementsAre('h', 'o', '\0')), 527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ElementsAre('l', 'o', '\0'))); 528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests for ElementsAreArray(). Since ElementsAreArray() shares most 531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// of the implementation with ElementsAre(), we don't test it as 532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// thoroughly here. 533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 534c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) { 535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a[] = { 1, 2, 3 }; 536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<int> test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); 538c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAreArray(a)); 539c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector[2] = 0; 541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, Not(ElementsAreArray(a))); 542c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 544c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) { 545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* a[] = { "one", "two", "three" }; 546c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); 548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAreArray(a, GMOCK_ARRAY_SIZE_(a))); 549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char** p = a; 551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector[0] = "1"; 552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GMOCK_ARRAY_SIZE_(a)))); 553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 555c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) { 556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* a[] = { "one", "two", "three" }; 557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector(a, a + GMOCK_ARRAY_SIZE_(a)); 559c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAreArray(a)); 560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector[0] = "1"; 562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, Not(ElementsAreArray(a))); 563c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 565c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) { 566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<string> kMatcherArray[] = 567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { StrEq("one"), StrEq("two"), StrEq("three") }; 568c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch vector<string> test_vector; 570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("one"); 571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("two"); 572c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("three"); 573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, ElementsAreArray(kMatcherArray)); 574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch test_vector.push_back("three"); 576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(test_vector, Not(ElementsAreArray(kMatcherArray))); 577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 579c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Since ElementsAre() and ElementsAreArray() share much of the 580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// implementation, we only do a sanity test for native arrays here. 581c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ElementsAreArrayTest, WorksWithNativeArray) { 582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::string a[] = { "hi", "ho" }; 583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ::std::string b[] = { "hi", "ho" }; 584c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, ElementsAreArray(b)); 586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, ElementsAreArray(b, 2)); 587c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Not(ElementsAreArray(b, 1))); 588c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests for the MATCHER*() macro family. 591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a simple MATCHER() definition works. 593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 594c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(IsEven, "") { return (arg % 2) == 0; } 595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 596c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherMacroTest, Works) { 597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = IsEven(); 598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(6)); 599c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(7)); 600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is even", Describe(m)); 602c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("not (is even)", DescribeNegation(m)); 603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 6)); 604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 7)); 605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 607dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// This also tests that the description string can reference 'negation'. 608dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenMATCHER(IsEven2, negation ? "is odd" : "is even") { 609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if ((arg % 2) == 0) { 610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that we can stream to result_listener, a listener 611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // supplied by the MATCHER macro implicitly. 612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *result_listener << "OK"; 613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 615c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *result_listener << "% 2 == " << (arg % 2); 616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 620dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// This also tests that the description string can reference matcher 621dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// parameters. 622dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenMATCHER_P2(EqSumOf, x, y, 623dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen string(negation ? "doesn't equal" : "equals") + " the sum of " + 624dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen PrintToString(x) + " and " + PrintToString(y)) { 625c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (arg == (x + y)) { 626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *result_listener << "OK"; 627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return true; 628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Verifies that we can stream to the underlying stream of 630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // result_listener. 631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (result_listener->stream() != NULL) { 632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch *result_listener->stream() << "diff == " << (x + y - arg); 633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 634c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return false; 635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 638dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// Tests that the matcher description can reference 'negation' and the 639dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// matcher parameters. 640dc0f95d653279beabeb9817299e2902918ba123eKristian MonsenTEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) { 641dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen const Matcher<int> m1 = IsEven2(); 642dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("is even", Describe(m1)); 643dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("is odd", DescribeNegation(m1)); 644dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 645dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen const Matcher<int> m2 = EqSumOf(5, 9); 646dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("equals the sum of 5 and 9", Describe(m2)); 647dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2)); 648dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen} 649dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen 650dc0f95d653279beabeb9817299e2902918ba123eKristian Monsen// Tests explaining match result in a MATCHER* macro. 651c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherMacroTest, CanExplainMatchResult) { 652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m1 = IsEven2(); 653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("OK", Explain(m1, 4)); 654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("% 2 == 1", Explain(m1, 5)); 655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m2 = EqSumOf(1, 2); 657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("OK", Explain(m2, 3)); 658c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("diff == -1", Explain(m2, 4)); 659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the body of MATCHER() can reference the type of the 662c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// value being matched. 663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 664c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(IsEmptyString, "") { 665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StaticAssertTypeEq< ::std::string, arg_type>(); 666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == ""; 667c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 669c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(IsEmptyStringByRef, "") { 670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StaticAssertTypeEq<const ::std::string&, arg_type>(); 671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == ""; 672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 674c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherMacroTest, CanReferenceArgType) { 675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher< ::std::string> m1 = IsEmptyString(); 676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m1.Matches("")); 677c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const ::std::string&> m2 = IsEmptyStringByRef(); 679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m2.Matches("")); 680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MATCHER() can be used in a namespace. 683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace matcher_test { 685c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(IsOdd, "") { return (arg % 2) != 0; } 686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace matcher_test 687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 688c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherMacroTest, WorksInNamespace) { 689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<int> m = matcher_test::IsOdd(); 690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(4)); 691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(5)); 692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that Value() can be used to compose matchers. 695c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(IsPositiveOdd, "") { 696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return Value(arg, matcher_test::IsOdd()) && arg > 0; 697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 698c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 699c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherMacroTest, CanBeComposedUsingValue) { 700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(3, IsPositiveOdd()); 701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(4, Not(IsPositiveOdd())); 702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(-1, Not(IsPositiveOdd())); 703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a simple MATCHER_P() definition works. 706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 707c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; } 708c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 709c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPMacroTest, Works) { 710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = IsGreaterThan32And(5); 711c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(36)); 712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(5)); 713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 714c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is greater than 32 and 5", Describe(m)); 715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m)); 716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 36)); 717c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 5)); 718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the description is calculated correctly from the matcher name. 721c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; } 722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 723c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPMacroTest, GeneratesCorrectDescription) { 724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<int> m = _is_Greater_Than32and_(5); 725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is greater than 32 and 5", Describe(m)); 727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m)); 728c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 36)); 729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 5)); 730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 732c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a MATCHER_P matcher can be explicitly instantiated with 733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// a reference parameter type. 734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass UncopyableFoo { 736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch explicit UncopyableFoo(char value) : value_(value) {} 738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UncopyableFoo(const UncopyableFoo&); 740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void operator=(const UncopyableFoo&); 741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch char value_; 743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 745c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; } 746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 747c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) { 748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UncopyableFoo foo1('1'), foo2('2'); 749c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const UncopyableFoo&> m = 750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ReferencesUncopyable<const UncopyableFoo&>(foo1); 751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(foo1)); 753c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(foo2)); 754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We don't want the address of the parameter printed, as most 756c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // likely it will just annoy the user. If the address is 757c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // interesting, the user should consider passing the parameter by 758c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // pointer instead. 759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("references uncopyable 1-byte object <31>", Describe(m)); 760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the body of MATCHER_Pn() can reference the parameter 764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// types. 765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 766c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") { 767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StaticAssertTypeEq<int, foo_type>(); 768c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StaticAssertTypeEq<long, bar_type>(); // NOLINT 769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch StaticAssertTypeEq<char, baz_type>(); 770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == 0; 771c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 772c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 773c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, CanReferenceParamTypes) { 774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a')); 775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 776c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a MATCHER_Pn matcher can be explicitly instantiated with 778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// reference parameter types. 779c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 780c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P2(ReferencesAnyOf, variable1, variable2, "") { 781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return &arg == &variable1 || &arg == &variable2; 782c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 784c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) { 785c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UncopyableFoo foo1('1'), foo2('2'), foo3('3'); 786c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const UncopyableFoo&> m = 787c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2); 788c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(foo1)); 790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(foo2)); 791c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(foo3)); 792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 793c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 794c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, 795c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) { 796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch UncopyableFoo foo1('1'), foo2('2'); 797c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const UncopyableFoo&> m = 798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2); 799c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 800c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We don't want the addresses of the parameters printed, as most 801c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // likely they will just annoy the user. If the addresses are 802c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // interesting, the user should consider passing the parameters by 803c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // pointers instead. 804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("references any of (1-byte object <31>, 1-byte object <32>)", 805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Describe(m)); 806c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 808c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a simple MATCHER_P2() definition works. 809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 810c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; } 811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 812c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, Works) { 813c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const Matcher<const long&> m = IsNotInClosedRange(10, 20); // NOLINT 814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(m.Matches(36L)); 815c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(m.Matches(15L)); 816c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 817c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("is not in closed range (10, 20)", Describe(m)); 818c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("not (is not in closed range (10, 20))", DescribeNegation(m)); 819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 36L)); 820c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, 15L)); 821c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 822c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 823c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that MATCHER*() definitions can be overloaded on the number 824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// of parameters; also tests MATCHER_Pn() where n >= 3. 825c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 826c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER(EqualsSumOf, "") { return arg == 0; } 827c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P(EqualsSumOf, a, "") { return arg == a; } 828c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; } 829c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; } 830c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; } 831c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; } 832c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") { 833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == a + b + c + d + e + f; 834c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 835c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") { 836c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == a + b + c + d + e + f + g; 837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 838c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") { 839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == a + b + c + d + e + f + g + h; 840c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 841c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") { 842c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == a + b + c + d + e + f + g + h + i; 843c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 844c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") { 845c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == a + b + c + d + e + f + g + h + i + j; 846c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 847c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 848c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) { 849c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(0, EqualsSumOf()); 850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(1, EqualsSumOf(1)); 851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(12, EqualsSumOf(10, 2)); 852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(123, EqualsSumOf(100, 20, 3)); 853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4)); 854c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5)); 855c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdef", 856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')); 857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefg", 858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g')); 859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefgh", 860c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 861c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "h")); 862c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefghi", 863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 864c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "h", 'i')); 865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefghij", 866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "h", 'i', ::std::string("j"))); 868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 869c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(1, Not(EqualsSumOf())); 870c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(-1, Not(EqualsSumOf(1))); 871c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(-12, Not(EqualsSumOf(10, 2))); 872c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3))); 873c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4))); 874c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5))); 875c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdef ", 876c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'))); 877c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefg ", 878c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 879c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 'g'))); 880c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefgh ", 881c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "h"))); 883c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefghi ", 884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 885c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "h", 'i'))); 886c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcdefghij ", 887c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 888c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "h", 'i', ::std::string("j")))); 889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 890c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 891c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that a MATCHER_Pn() definition can be instantiated with any 892c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// compatible parameter types. 893c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) { 894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3))); 895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d")); 896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3)))); 898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d"))); 899c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 900c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 901c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the matcher body can promote the parameter types. 902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 903c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P2(EqConcat, prefix, suffix, "") { 904c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The following lines promote the two parameters to desired types. 905c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch std::string prefix_str(prefix); 906c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch char suffix_char = static_cast<char>(suffix); 907c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return arg == prefix_str + suffix_char; 908c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 909c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 910c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, SimpleTypePromotion) { 911c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<std::string> no_promo = 912c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqConcat(std::string("foo"), 't'); 913c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const std::string&> promo = 914c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqConcat("foo", static_cast<int>('t')); 915c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(no_promo.Matches("fool")); 916c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FALSE(promo.Matches("fool")); 917c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(no_promo.Matches("foot")); 918c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(promo.Matches("foot")); 919c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 920c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 921c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Verifies the type of a MATCHER*. 922c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 923c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, TypesAreCorrect) { 924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable. 925c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcher a0 = EqualsSumOf(); 926c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 927c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable. 928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1); 929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 930c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk 931c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // variable, and so on. 932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2'); 933c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3'); 934c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4'); 935c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP5<int, int, int, int, char> a5 = 936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(1, 2, 3, 4, '5'); 937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 = 938c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(1, 2, 3, 4, 5, '6'); 939c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 = 940c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(1, 2, 3, 4, 5, 6, '7'); 941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 = 942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8'); 943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 = 944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9'); 945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 = 946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0'); 947c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 948c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 949c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that matcher-typed parameters can be used in Value() inside a 950c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// MATCHER_Pn definition. 951c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 952c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Succeeds if arg matches exactly 2 of the 3 matchers. 953c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochMATCHER_P3(TwoOf, m1, m2, m3, "") { 954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int count = static_cast<int>(Value(arg, m1)) 955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch + static_cast<int>(Value(arg, m2)) + static_cast<int>(Value(arg, m3)); 956c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return count == 2; 957c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 959c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) { 960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10))); 961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0)))); 962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 964c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests Contains(). 965c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 966c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, ListMatchesWhenElementIsInContainer) { 967c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch list<int> some_list; 968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_list.push_back(3); 969c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_list.push_back(1); 970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_list.push_back(2); 971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_list, Contains(1)); 972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_list, Contains(Gt(2.5))); 973c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_list, Contains(Eq(2.0f))); 974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 975c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch list<string> another_list; 976c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_list.push_back("fee"); 977c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_list.push_back("fie"); 978c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_list.push_back("foe"); 979c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_list.push_back("fum"); 980c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(another_list, Contains(string("fee"))); 981c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 982c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 983c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) { 984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch list<int> some_list; 985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_list.push_back(3); 986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_list.push_back(1); 987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_list, Not(Contains(4))); 988c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 990c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, SetMatchesWhenElementIsInContainer) { 991c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch set<int> some_set; 992c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_set.insert(3); 993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_set.insert(1); 994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_set.insert(2); 995c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_set, Contains(Eq(1.0))); 996c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_set, Contains(Eq(3.0f))); 997c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_set, Contains(2)); 998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch set<const char*> another_set; 1000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_set.insert("fee"); 1001c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_set.insert("fie"); 1002c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_set.insert("foe"); 1003c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_set.insert("fum"); 1004c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(another_set, Contains(Eq(string("fum")))); 1005c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1006c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1007c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) { 1008c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch set<int> some_set; 1009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_set.insert(3); 1010c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_set.insert(1); 1011c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_set, Not(Contains(4))); 1012c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch set<const char*> c_string_set; 1014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch c_string_set.insert("hello"); 1015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(c_string_set, Not(Contains(string("hello").c_str()))); 1016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1018c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, ExplainsMatchResultCorrectly) { 1019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a[2] = { 1, 2 }; 1020c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<const int(&)[2]> m = Contains(2); 1021c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose element #1 matches", Explain(m, a)); 1022c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1023c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Contains(3); 1024c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, a)); 1025c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1026c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Contains(GreaterThan(0)); 1027c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("whose element #0 matches, which is 1 more than 0", Explain(m, a)); 1028c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1029c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch m = Contains(GreaterThan(10)); 1030c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("", Explain(m, a)); 1031c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1032c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1033c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, DescribesItselfCorrectly) { 1034c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<int> > m = Contains(1); 1035c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("contains at least one element that is equal to 1", Describe(m)); 1036c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1037c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Matcher<vector<int> > m2 = Not(m); 1038c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ("doesn't contain any element that is equal to 1", Describe(m2)); 1039c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1040c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1041c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, MapMatchesWhenElementIsInContainer) { 1042c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch map<const char*, int> my_map; 1043c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* bar = "a string"; 1044c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch my_map[bar] = 2; 1045c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(my_map, Contains(pair<const char* const, int>(bar, 2))); 1046c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1047c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch map<string, int> another_map; 1048c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_map["fee"] = 1; 1049c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_map["fie"] = 2; 1050c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_map["foe"] = 3; 1051c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch another_map["fum"] = 4; 1052c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(another_map, Contains(pair<const string, int>(string("fee"), 1))); 1053c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(another_map, Contains(pair<const string, int>("fie", 2))); 1054c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1055c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1056c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) { 1057c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch map<int, int> some_map; 1058c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_map[1] = 11; 1059c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch some_map[2] = 22; 1060c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(some_map, Not(Contains(pair<const int, int>(2, 23)))); 1061c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1062c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1063c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) { 1064c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const char* string_array[] = { "fee", "fie", "foe", "fum" }; 1065c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(string_array, Contains(Eq(string("fum")))); 1066c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1067c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1068c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) { 1069c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int int_array[] = { 1, 2, 3, 4 }; 1070c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(int_array, Not(Contains(5))); 1071c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1072c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1073c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, AcceptsMatcher) { 1074c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a[] = { 1, 2, 3 }; 1075c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Contains(Gt(2))); 1076c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Not(Contains(Gt(4)))); 1077c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1078c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1079c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, WorksForNativeArrayAsTuple) { 1080c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int a[] = { 1, 2 }; 1081c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch const int* const pointer = a; 1082c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(pointer, 2), Contains(1)); 1083c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(make_tuple(pointer, 2), Not(Contains(Gt(3)))); 1084c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1085c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1086c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ContainsTest, WorksForTwoDimensionalNativeArray) { 1087c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; 1088c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Contains(ElementsAre(4, 5, 6))); 1089c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Contains(Contains(5))); 1090c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5)))); 1091c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_THAT(a, Contains(Not(Contains(5)))); 1092c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1093c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1094ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsennamespace adl_test { 1095ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1096ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf 1097ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// don't issue unqualified recursive calls. If they do, the argument dependent 1098ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found 1099ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// as a candidate and the compilation will break due to an ambiguous overload. 1100ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1101ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// The matcher must be in the same namespace as AllOf/AnyOf to make argument 1102ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// dependent lookup find those. 1103ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian MonsenMATCHER(M, "") { return true; } 1104ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1105ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsentemplate <typename T1, typename T2> 1106ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsenbool AllOf(const T1& t1, const T2& t2) { return true; } 1107ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1108ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian MonsenTEST(AllOfTest, DoesNotCallAllOfUnqualified) { 1109ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen EXPECT_THAT(42, testing::AllOf( 1110ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen M(), M(), M(), M(), M(), M(), M(), M(), M(), M())); 1111ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen} 1112ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1113ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsentemplate <typename T1, typename T2> bool 1114ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian MonsenAnyOf(const T1& t1, const T2& t2) { return true; } 1115ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1116ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian MonsenTEST(AnyOfTest, DoesNotCallAnyOfUnqualified) { 1117ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen EXPECT_THAT(42, testing::AnyOf( 1118ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen M(), M(), M(), M(), M(), M(), M(), M(), M(), M())); 1119ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen} 1120ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1121ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen} // namespace adl_test 1122ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen 1123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#ifdef _MSC_VER 1124ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# pragma warning(pop) 1125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif 1126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace 1128