1// Copyright 2008, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30// Google Mock - a framework for writing C++ mock classes. 31// 32// This file tests the built-in matchers generated by a script. 33 34// Silence warning C4244: 'initializing': conversion from 'int' to 'short', 35// possible loss of data and C4100, unreferenced local parameter 36#ifdef _MSC_VER 37# pragma warning(push) 38# pragma warning(disable:4244) 39# pragma warning(disable:4100) 40#endif 41 42#include "gmock/gmock-generated-matchers.h" 43 44#include <list> 45#include <map> 46#include <memory> 47#include <set> 48#include <sstream> 49#include <string> 50#include <utility> 51#include <vector> 52 53#include "gmock/gmock.h" 54#include "gtest/gtest.h" 55#include "gtest/gtest-spi.h" 56 57namespace { 58 59using std::list; 60using std::map; 61using std::pair; 62using std::set; 63using std::stringstream; 64using std::vector; 65using testing::get; 66using testing::make_tuple; 67using testing::tuple; 68using testing::_; 69using testing::AllOf; 70using testing::AnyOf; 71using testing::Args; 72using testing::Contains; 73using testing::ElementsAre; 74using testing::ElementsAreArray; 75using testing::Eq; 76using testing::Ge; 77using testing::Gt; 78using testing::Le; 79using testing::Lt; 80using testing::MakeMatcher; 81using testing::Matcher; 82using testing::MatcherInterface; 83using testing::MatchResultListener; 84using testing::Ne; 85using testing::Not; 86using testing::Pointee; 87using testing::PrintToString; 88using testing::Ref; 89using testing::StaticAssertTypeEq; 90using testing::StrEq; 91using testing::Value; 92using testing::internal::ElementsAreArrayMatcher; 93 94// Returns the description of the given matcher. 95template <typename T> 96std::string Describe(const Matcher<T>& m) { 97 stringstream ss; 98 m.DescribeTo(&ss); 99 return ss.str(); 100} 101 102// Returns the description of the negation of the given matcher. 103template <typename T> 104std::string DescribeNegation(const Matcher<T>& m) { 105 stringstream ss; 106 m.DescribeNegationTo(&ss); 107 return ss.str(); 108} 109 110// Returns the reason why x matches, or doesn't match, m. 111template <typename MatcherType, typename Value> 112std::string Explain(const MatcherType& m, const Value& x) { 113 stringstream ss; 114 m.ExplainMatchResultTo(x, &ss); 115 return ss.str(); 116} 117 118// Tests Args<k0, ..., kn>(m). 119 120TEST(ArgsTest, AcceptsZeroTemplateArg) { 121 const tuple<int, bool> t(5, true); 122 EXPECT_THAT(t, Args<>(Eq(tuple<>()))); 123 EXPECT_THAT(t, Not(Args<>(Ne(tuple<>())))); 124} 125 126TEST(ArgsTest, AcceptsOneTemplateArg) { 127 const tuple<int, bool> t(5, true); 128 EXPECT_THAT(t, Args<0>(Eq(make_tuple(5)))); 129 EXPECT_THAT(t, Args<1>(Eq(make_tuple(true)))); 130 EXPECT_THAT(t, Not(Args<1>(Eq(make_tuple(false))))); 131} 132 133TEST(ArgsTest, AcceptsTwoTemplateArgs) { 134 const tuple<short, int, long> t(4, 5, 6L); // NOLINT 135 136 EXPECT_THAT(t, (Args<0, 1>(Lt()))); 137 EXPECT_THAT(t, (Args<1, 2>(Lt()))); 138 EXPECT_THAT(t, Not(Args<0, 2>(Gt()))); 139} 140 141TEST(ArgsTest, AcceptsRepeatedTemplateArgs) { 142 const tuple<short, int, long> t(4, 5, 6L); // NOLINT 143 EXPECT_THAT(t, (Args<0, 0>(Eq()))); 144 EXPECT_THAT(t, Not(Args<1, 1>(Ne()))); 145} 146 147TEST(ArgsTest, AcceptsDecreasingTemplateArgs) { 148 const tuple<short, int, long> t(4, 5, 6L); // NOLINT 149 EXPECT_THAT(t, (Args<2, 0>(Gt()))); 150 EXPECT_THAT(t, Not(Args<2, 1>(Lt()))); 151} 152 153// The MATCHER*() macros trigger warning C4100 (unreferenced formal 154// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in 155// the macro definition, as the warnings are generated when the macro 156// is expanded and macro expansion cannot contain #pragma. Therefore 157// we suppress them here. 158#ifdef _MSC_VER 159# pragma warning(push) 160# pragma warning(disable:4100) 161#endif 162 163MATCHER(SumIsZero, "") { 164 return get<0>(arg) + get<1>(arg) + get<2>(arg) == 0; 165} 166 167TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) { 168 EXPECT_THAT(make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero()))); 169 EXPECT_THAT(make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero()))); 170} 171 172TEST(ArgsTest, CanBeNested) { 173 const tuple<short, int, long, int> t(4, 5, 6L, 6); // NOLINT 174 EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq())))); 175 EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt())))); 176} 177 178TEST(ArgsTest, CanMatchTupleByValue) { 179 typedef tuple<char, int, int> Tuple3; 180 const Matcher<Tuple3> m = Args<1, 2>(Lt()); 181 EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2))); 182 EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2))); 183} 184 185TEST(ArgsTest, CanMatchTupleByReference) { 186 typedef tuple<char, char, int> Tuple3; 187 const Matcher<const Tuple3&> m = Args<0, 1>(Lt()); 188 EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2))); 189 EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2))); 190} 191 192// Validates that arg is printed as str. 193MATCHER_P(PrintsAs, str, "") { 194 return testing::PrintToString(arg) == str; 195} 196 197TEST(ArgsTest, AcceptsTenTemplateArgs) { 198 EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9), 199 (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>( 200 PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)")))); 201 EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9), 202 Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>( 203 PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)")))); 204} 205 206TEST(ArgsTest, DescirbesSelfCorrectly) { 207 const Matcher<tuple<int, bool, char> > m = Args<2, 0>(Lt()); 208 EXPECT_EQ("are a tuple whose fields (#2, #0) are a pair where " 209 "the first < the second", 210 Describe(m)); 211} 212 213TEST(ArgsTest, DescirbesNestedArgsCorrectly) { 214 const Matcher<const tuple<int, bool, char, int>&> m = 215 Args<0, 2, 3>(Args<2, 0>(Lt())); 216 EXPECT_EQ("are a tuple whose fields (#0, #2, #3) are a tuple " 217 "whose fields (#2, #0) are a pair where the first < the second", 218 Describe(m)); 219} 220 221TEST(ArgsTest, DescribesNegationCorrectly) { 222 const Matcher<tuple<int, char> > m = Args<1, 0>(Gt()); 223 EXPECT_EQ("are a tuple whose fields (#1, #0) aren't a pair " 224 "where the first > the second", 225 DescribeNegation(m)); 226} 227 228TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) { 229 const Matcher<tuple<bool, int, int> > m = Args<1, 2>(Eq()); 230 EXPECT_EQ("whose fields (#1, #2) are (42, 42)", 231 Explain(m, make_tuple(false, 42, 42))); 232 EXPECT_EQ("whose fields (#1, #2) are (42, 43)", 233 Explain(m, make_tuple(false, 42, 43))); 234} 235 236// For testing Args<>'s explanation. 237class LessThanMatcher : public MatcherInterface<tuple<char, int> > { 238 public: 239 virtual void DescribeTo(::std::ostream* os) const {} 240 241 virtual bool MatchAndExplain(tuple<char, int> value, 242 MatchResultListener* listener) const { 243 const int diff = get<0>(value) - get<1>(value); 244 if (diff > 0) { 245 *listener << "where the first value is " << diff 246 << " more than the second"; 247 } 248 return diff < 0; 249 } 250}; 251 252Matcher<tuple<char, int> > LessThan() { 253 return MakeMatcher(new LessThanMatcher); 254} 255 256TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) { 257 const Matcher<tuple<char, int, int> > m = Args<0, 2>(LessThan()); 258 EXPECT_EQ("whose fields (#0, #2) are ('a' (97, 0x61), 42), " 259 "where the first value is 55 more than the second", 260 Explain(m, make_tuple('a', 42, 42))); 261 EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)", 262 Explain(m, make_tuple('\0', 42, 43))); 263} 264 265// For testing ExplainMatchResultTo(). 266class GreaterThanMatcher : public MatcherInterface<int> { 267 public: 268 explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {} 269 270 virtual void DescribeTo(::std::ostream* os) const { 271 *os << "is greater than " << rhs_; 272 } 273 274 virtual bool MatchAndExplain(int lhs, 275 MatchResultListener* listener) const { 276 const int diff = lhs - rhs_; 277 if (diff > 0) { 278 *listener << "which is " << diff << " more than " << rhs_; 279 } else if (diff == 0) { 280 *listener << "which is the same as " << rhs_; 281 } else { 282 *listener << "which is " << -diff << " less than " << rhs_; 283 } 284 285 return lhs > rhs_; 286 } 287 288 private: 289 int rhs_; 290}; 291 292Matcher<int> GreaterThan(int n) { 293 return MakeMatcher(new GreaterThanMatcher(n)); 294} 295 296// Tests for ElementsAre(). 297 298TEST(ElementsAreTest, CanDescribeExpectingNoElement) { 299 Matcher<const vector<int>&> m = ElementsAre(); 300 EXPECT_EQ("is empty", Describe(m)); 301} 302 303TEST(ElementsAreTest, CanDescribeExpectingOneElement) { 304 Matcher<vector<int> > m = ElementsAre(Gt(5)); 305 EXPECT_EQ("has 1 element that is > 5", Describe(m)); 306} 307 308TEST(ElementsAreTest, CanDescribeExpectingManyElements) { 309 Matcher<list<std::string> > m = ElementsAre(StrEq("one"), "two"); 310 EXPECT_EQ("has 2 elements where\n" 311 "element #0 is equal to \"one\",\n" 312 "element #1 is equal to \"two\"", Describe(m)); 313} 314 315TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) { 316 Matcher<vector<int> > m = ElementsAre(); 317 EXPECT_EQ("isn't empty", DescribeNegation(m)); 318} 319 320TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) { 321 Matcher<const list<int>& > m = ElementsAre(Gt(5)); 322 EXPECT_EQ("doesn't have 1 element, or\n" 323 "element #0 isn't > 5", DescribeNegation(m)); 324} 325 326TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) { 327 Matcher<const list<std::string>&> m = ElementsAre("one", "two"); 328 EXPECT_EQ("doesn't have 2 elements, or\n" 329 "element #0 isn't equal to \"one\", or\n" 330 "element #1 isn't equal to \"two\"", DescribeNegation(m)); 331} 332 333TEST(ElementsAreTest, DoesNotExplainTrivialMatch) { 334 Matcher<const list<int>& > m = ElementsAre(1, Ne(2)); 335 336 list<int> test_list; 337 test_list.push_back(1); 338 test_list.push_back(3); 339 EXPECT_EQ("", Explain(m, test_list)); // No need to explain anything. 340} 341 342TEST(ElementsAreTest, ExplainsNonTrivialMatch) { 343 Matcher<const vector<int>& > m = 344 ElementsAre(GreaterThan(1), 0, GreaterThan(2)); 345 346 const int a[] = { 10, 0, 100 }; 347 vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 348 EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n" 349 "and whose element #2 matches, which is 98 more than 2", 350 Explain(m, test_vector)); 351} 352 353TEST(ElementsAreTest, CanExplainMismatchWrongSize) { 354 Matcher<const list<int>& > m = ElementsAre(1, 3); 355 356 list<int> test_list; 357 // No need to explain when the container is empty. 358 EXPECT_EQ("", Explain(m, test_list)); 359 360 test_list.push_back(1); 361 EXPECT_EQ("which has 1 element", Explain(m, test_list)); 362} 363 364TEST(ElementsAreTest, CanExplainMismatchRightSize) { 365 Matcher<const vector<int>& > m = ElementsAre(1, GreaterThan(5)); 366 367 vector<int> v; 368 v.push_back(2); 369 v.push_back(1); 370 EXPECT_EQ("whose element #0 doesn't match", Explain(m, v)); 371 372 v[0] = 1; 373 EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5", 374 Explain(m, v)); 375} 376 377TEST(ElementsAreTest, MatchesOneElementVector) { 378 vector<std::string> test_vector; 379 test_vector.push_back("test string"); 380 381 EXPECT_THAT(test_vector, ElementsAre(StrEq("test string"))); 382} 383 384TEST(ElementsAreTest, MatchesOneElementList) { 385 list<std::string> test_list; 386 test_list.push_back("test string"); 387 388 EXPECT_THAT(test_list, ElementsAre("test string")); 389} 390 391TEST(ElementsAreTest, MatchesThreeElementVector) { 392 vector<std::string> test_vector; 393 test_vector.push_back("one"); 394 test_vector.push_back("two"); 395 test_vector.push_back("three"); 396 397 EXPECT_THAT(test_vector, ElementsAre("one", StrEq("two"), _)); 398} 399 400TEST(ElementsAreTest, MatchesOneElementEqMatcher) { 401 vector<int> test_vector; 402 test_vector.push_back(4); 403 404 EXPECT_THAT(test_vector, ElementsAre(Eq(4))); 405} 406 407TEST(ElementsAreTest, MatchesOneElementAnyMatcher) { 408 vector<int> test_vector; 409 test_vector.push_back(4); 410 411 EXPECT_THAT(test_vector, ElementsAre(_)); 412} 413 414TEST(ElementsAreTest, MatchesOneElementValue) { 415 vector<int> test_vector; 416 test_vector.push_back(4); 417 418 EXPECT_THAT(test_vector, ElementsAre(4)); 419} 420 421TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) { 422 vector<int> test_vector; 423 test_vector.push_back(1); 424 test_vector.push_back(2); 425 test_vector.push_back(3); 426 427 EXPECT_THAT(test_vector, ElementsAre(1, Eq(2), _)); 428} 429 430TEST(ElementsAreTest, MatchesTenElementVector) { 431 const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 432 vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 433 434 EXPECT_THAT(test_vector, 435 // The element list can contain values and/or matchers 436 // of different types. 437 ElementsAre(0, Ge(0), _, 3, 4, Ne(2), Eq(6), 7, 8, _)); 438} 439 440TEST(ElementsAreTest, DoesNotMatchWrongSize) { 441 vector<std::string> test_vector; 442 test_vector.push_back("test string"); 443 test_vector.push_back("test string"); 444 445 Matcher<vector<std::string> > m = ElementsAre(StrEq("test string")); 446 EXPECT_FALSE(m.Matches(test_vector)); 447} 448 449TEST(ElementsAreTest, DoesNotMatchWrongValue) { 450 vector<std::string> test_vector; 451 test_vector.push_back("other string"); 452 453 Matcher<vector<std::string> > m = ElementsAre(StrEq("test string")); 454 EXPECT_FALSE(m.Matches(test_vector)); 455} 456 457TEST(ElementsAreTest, DoesNotMatchWrongOrder) { 458 vector<std::string> test_vector; 459 test_vector.push_back("one"); 460 test_vector.push_back("three"); 461 test_vector.push_back("two"); 462 463 Matcher<vector<std::string> > m = 464 ElementsAre(StrEq("one"), StrEq("two"), StrEq("three")); 465 EXPECT_FALSE(m.Matches(test_vector)); 466} 467 468TEST(ElementsAreTest, WorksForNestedContainer) { 469 const char* strings[] = { 470 "Hi", 471 "world" 472 }; 473 474 vector<list<char> > nested; 475 for (size_t i = 0; i < GTEST_ARRAY_SIZE_(strings); i++) { 476 nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i]))); 477 } 478 479 EXPECT_THAT(nested, ElementsAre(ElementsAre('H', Ne('e')), 480 ElementsAre('w', 'o', _, _, 'd'))); 481 EXPECT_THAT(nested, Not(ElementsAre(ElementsAre('H', 'e'), 482 ElementsAre('w', 'o', _, _, 'd')))); 483} 484 485TEST(ElementsAreTest, WorksWithByRefElementMatchers) { 486 int a[] = { 0, 1, 2 }; 487 vector<int> v(a, a + GTEST_ARRAY_SIZE_(a)); 488 489 EXPECT_THAT(v, ElementsAre(Ref(v[0]), Ref(v[1]), Ref(v[2]))); 490 EXPECT_THAT(v, Not(ElementsAre(Ref(v[0]), Ref(v[1]), Ref(a[2])))); 491} 492 493TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) { 494 int a[] = { 0, 1, 2 }; 495 vector<int> v(a, a + GTEST_ARRAY_SIZE_(a)); 496 497 EXPECT_THAT(&v, Pointee(ElementsAre(0, 1, _))); 498 EXPECT_THAT(&v, Not(Pointee(ElementsAre(0, _, 3)))); 499} 500 501TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) { 502 int array[] = { 0, 1, 2 }; 503 EXPECT_THAT(array, ElementsAre(0, 1, _)); 504 EXPECT_THAT(array, Not(ElementsAre(1, _, _))); 505 EXPECT_THAT(array, Not(ElementsAre(0, _))); 506} 507 508class NativeArrayPassedAsPointerAndSize { 509 public: 510 NativeArrayPassedAsPointerAndSize() {} 511 512 MOCK_METHOD2(Helper, void(int* array, int size)); 513 514 private: 515 GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize); 516}; 517 518TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) { 519 int array[] = { 0, 1 }; 520 ::testing::tuple<int*, size_t> array_as_tuple(array, 2); 521 EXPECT_THAT(array_as_tuple, ElementsAre(0, 1)); 522 EXPECT_THAT(array_as_tuple, Not(ElementsAre(0))); 523 524 NativeArrayPassedAsPointerAndSize helper; 525 EXPECT_CALL(helper, Helper(_, _)) 526 .With(ElementsAre(0, 1)); 527 helper.Helper(array, 2); 528} 529 530TEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) { 531 const char a2[][3] = { "hi", "lo" }; 532 EXPECT_THAT(a2, ElementsAre(ElementsAre('h', 'i', '\0'), 533 ElementsAre('l', 'o', '\0'))); 534 EXPECT_THAT(a2, ElementsAre(StrEq("hi"), StrEq("lo"))); 535 EXPECT_THAT(a2, ElementsAre(Not(ElementsAre('h', 'o', '\0')), 536 ElementsAre('l', 'o', '\0'))); 537} 538 539TEST(ElementsAreTest, AcceptsStringLiteral) { 540 std::string array[] = {"hi", "one", "two"}; 541 EXPECT_THAT(array, ElementsAre("hi", "one", "two")); 542 EXPECT_THAT(array, Not(ElementsAre("hi", "one", "too"))); 543} 544 545#ifndef _MSC_VER 546 547// The following test passes a value of type const char[] to a 548// function template that expects const T&. Some versions of MSVC 549// generates a compiler error C2665 for that. We believe it's a bug 550// in MSVC. Therefore this test is #if-ed out for MSVC. 551 552// Declared here with the size unknown. Defined AFTER the following test. 553extern const char kHi[]; 554 555TEST(ElementsAreTest, AcceptsArrayWithUnknownSize) { 556 // The size of kHi is not known in this test, but ElementsAre() should 557 // still accept it. 558 559 std::string array1[] = {"hi"}; 560 EXPECT_THAT(array1, ElementsAre(kHi)); 561 562 std::string array2[] = {"ho"}; 563 EXPECT_THAT(array2, Not(ElementsAre(kHi))); 564} 565 566const char kHi[] = "hi"; 567 568#endif // _MSC_VER 569 570TEST(ElementsAreTest, MakesCopyOfArguments) { 571 int x = 1; 572 int y = 2; 573 // This should make a copy of x and y. 574 ::testing::internal::ElementsAreMatcher<testing::tuple<int, int> > 575 polymorphic_matcher = ElementsAre(x, y); 576 // Changing x and y now shouldn't affect the meaning of the above matcher. 577 x = y = 0; 578 const int array1[] = { 1, 2 }; 579 EXPECT_THAT(array1, polymorphic_matcher); 580 const int array2[] = { 0, 0 }; 581 EXPECT_THAT(array2, Not(polymorphic_matcher)); 582} 583 584 585// Tests for ElementsAreArray(). Since ElementsAreArray() shares most 586// of the implementation with ElementsAre(), we don't test it as 587// thoroughly here. 588 589TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) { 590 const int a[] = { 1, 2, 3 }; 591 592 vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 593 EXPECT_THAT(test_vector, ElementsAreArray(a)); 594 595 test_vector[2] = 0; 596 EXPECT_THAT(test_vector, Not(ElementsAreArray(a))); 597} 598 599TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) { 600 const char* a[] = { "one", "two", "three" }; 601 602 vector<std::string> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 603 EXPECT_THAT(test_vector, ElementsAreArray(a, GTEST_ARRAY_SIZE_(a))); 604 605 const char** p = a; 606 test_vector[0] = "1"; 607 EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GTEST_ARRAY_SIZE_(a)))); 608} 609 610TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) { 611 const char* a[] = { "one", "two", "three" }; 612 613 vector<std::string> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 614 EXPECT_THAT(test_vector, ElementsAreArray(a)); 615 616 test_vector[0] = "1"; 617 EXPECT_THAT(test_vector, Not(ElementsAreArray(a))); 618} 619 620TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) { 621 const Matcher<std::string> kMatcherArray[] = {StrEq("one"), StrEq("two"), 622 StrEq("three")}; 623 624 vector<std::string> test_vector; 625 test_vector.push_back("one"); 626 test_vector.push_back("two"); 627 test_vector.push_back("three"); 628 EXPECT_THAT(test_vector, ElementsAreArray(kMatcherArray)); 629 630 test_vector.push_back("three"); 631 EXPECT_THAT(test_vector, Not(ElementsAreArray(kMatcherArray))); 632} 633 634TEST(ElementsAreArrayTest, CanBeCreatedWithVector) { 635 const int a[] = { 1, 2, 3 }; 636 vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 637 const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a)); 638 EXPECT_THAT(test_vector, ElementsAreArray(expected)); 639 test_vector.push_back(4); 640 EXPECT_THAT(test_vector, Not(ElementsAreArray(expected))); 641} 642 643#if GTEST_HAS_STD_INITIALIZER_LIST_ 644 645TEST(ElementsAreArrayTest, TakesInitializerList) { 646 const int a[5] = { 1, 2, 3, 4, 5 }; 647 EXPECT_THAT(a, ElementsAreArray({ 1, 2, 3, 4, 5 })); 648 EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 5, 4 }))); 649 EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 4, 6 }))); 650} 651 652TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) { 653 const std::string a[5] = {"a", "b", "c", "d", "e"}; 654 EXPECT_THAT(a, ElementsAreArray({ "a", "b", "c", "d", "e" })); 655 EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "e", "d" }))); 656 EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "d", "ef" }))); 657} 658 659TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) { 660 const int a[5] = { 1, 2, 3, 4, 5 }; 661 EXPECT_THAT(a, ElementsAreArray( 662 { Eq(1), Eq(2), Eq(3), Eq(4), Eq(5) })); 663 EXPECT_THAT(a, Not(ElementsAreArray( 664 { Eq(1), Eq(2), Eq(3), Eq(4), Eq(6) }))); 665} 666 667TEST(ElementsAreArrayTest, 668 TakesInitializerListOfDifferentTypedMatchers) { 669 const int a[5] = { 1, 2, 3, 4, 5 }; 670 // The compiler cannot infer the type of the initializer list if its 671 // elements have different types. We must explicitly specify the 672 // unified element type in this case. 673 EXPECT_THAT(a, ElementsAreArray<Matcher<int> >( 674 { Eq(1), Ne(-2), Ge(3), Le(4), Eq(5) })); 675 EXPECT_THAT(a, Not(ElementsAreArray<Matcher<int> >( 676 { Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) }))); 677} 678 679#endif // GTEST_HAS_STD_INITIALIZER_LIST_ 680 681TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) { 682 const int a[] = { 1, 2, 3 }; 683 const Matcher<int> kMatchers[] = { Eq(1), Eq(2), Eq(3) }; 684 vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 685 const vector<Matcher<int> > expected( 686 kMatchers, kMatchers + GTEST_ARRAY_SIZE_(kMatchers)); 687 EXPECT_THAT(test_vector, ElementsAreArray(expected)); 688 test_vector.push_back(4); 689 EXPECT_THAT(test_vector, Not(ElementsAreArray(expected))); 690} 691 692TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) { 693 const int a[] = { 1, 2, 3 }; 694 const vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 695 const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a)); 696 EXPECT_THAT(test_vector, ElementsAreArray(expected.begin(), expected.end())); 697 // Pointers are iterators, too. 698 EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a))); 699 // The empty range of NULL pointers should also be okay. 700 int* const null_int = NULL; 701 EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int))); 702 EXPECT_THAT((vector<int>()), ElementsAreArray(null_int, null_int)); 703} 704 705// Since ElementsAre() and ElementsAreArray() share much of the 706// implementation, we only do a sanity test for native arrays here. 707TEST(ElementsAreArrayTest, WorksWithNativeArray) { 708 ::std::string a[] = { "hi", "ho" }; 709 ::std::string b[] = { "hi", "ho" }; 710 711 EXPECT_THAT(a, ElementsAreArray(b)); 712 EXPECT_THAT(a, ElementsAreArray(b, 2)); 713 EXPECT_THAT(a, Not(ElementsAreArray(b, 1))); 714} 715 716TEST(ElementsAreArrayTest, SourceLifeSpan) { 717 const int a[] = { 1, 2, 3 }; 718 vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a)); 719 vector<int> expect(a, a + GTEST_ARRAY_SIZE_(a)); 720 ElementsAreArrayMatcher<int> matcher_maker = 721 ElementsAreArray(expect.begin(), expect.end()); 722 EXPECT_THAT(test_vector, matcher_maker); 723 // Changing in place the values that initialized matcher_maker should not 724 // affect matcher_maker anymore. It should have made its own copy of them. 725 typedef vector<int>::iterator Iter; 726 for (Iter it = expect.begin(); it != expect.end(); ++it) { *it += 10; } 727 EXPECT_THAT(test_vector, matcher_maker); 728 test_vector.push_back(3); 729 EXPECT_THAT(test_vector, Not(matcher_maker)); 730} 731 732// Tests for the MATCHER*() macro family. 733 734// Tests that a simple MATCHER() definition works. 735 736MATCHER(IsEven, "") { return (arg % 2) == 0; } 737 738TEST(MatcherMacroTest, Works) { 739 const Matcher<int> m = IsEven(); 740 EXPECT_TRUE(m.Matches(6)); 741 EXPECT_FALSE(m.Matches(7)); 742 743 EXPECT_EQ("is even", Describe(m)); 744 EXPECT_EQ("not (is even)", DescribeNegation(m)); 745 EXPECT_EQ("", Explain(m, 6)); 746 EXPECT_EQ("", Explain(m, 7)); 747} 748 749// This also tests that the description string can reference 'negation'. 750MATCHER(IsEven2, negation ? "is odd" : "is even") { 751 if ((arg % 2) == 0) { 752 // Verifies that we can stream to result_listener, a listener 753 // supplied by the MATCHER macro implicitly. 754 *result_listener << "OK"; 755 return true; 756 } else { 757 *result_listener << "% 2 == " << (arg % 2); 758 return false; 759 } 760} 761 762// This also tests that the description string can reference matcher 763// parameters. 764MATCHER_P2(EqSumOf, x, y, std::string(negation ? "doesn't equal" : "equals") + 765 " the sum of " + PrintToString(x) + " and " + 766 PrintToString(y)) { 767 if (arg == (x + y)) { 768 *result_listener << "OK"; 769 return true; 770 } else { 771 // Verifies that we can stream to the underlying stream of 772 // result_listener. 773 if (result_listener->stream() != NULL) { 774 *result_listener->stream() << "diff == " << (x + y - arg); 775 } 776 return false; 777 } 778} 779 780// Tests that the matcher description can reference 'negation' and the 781// matcher parameters. 782TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) { 783 const Matcher<int> m1 = IsEven2(); 784 EXPECT_EQ("is even", Describe(m1)); 785 EXPECT_EQ("is odd", DescribeNegation(m1)); 786 787 const Matcher<int> m2 = EqSumOf(5, 9); 788 EXPECT_EQ("equals the sum of 5 and 9", Describe(m2)); 789 EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2)); 790} 791 792// Tests explaining match result in a MATCHER* macro. 793TEST(MatcherMacroTest, CanExplainMatchResult) { 794 const Matcher<int> m1 = IsEven2(); 795 EXPECT_EQ("OK", Explain(m1, 4)); 796 EXPECT_EQ("% 2 == 1", Explain(m1, 5)); 797 798 const Matcher<int> m2 = EqSumOf(1, 2); 799 EXPECT_EQ("OK", Explain(m2, 3)); 800 EXPECT_EQ("diff == -1", Explain(m2, 4)); 801} 802 803// Tests that the body of MATCHER() can reference the type of the 804// value being matched. 805 806MATCHER(IsEmptyString, "") { 807 StaticAssertTypeEq< ::std::string, arg_type>(); 808 return arg == ""; 809} 810 811MATCHER(IsEmptyStringByRef, "") { 812 StaticAssertTypeEq<const ::std::string&, arg_type>(); 813 return arg == ""; 814} 815 816TEST(MatcherMacroTest, CanReferenceArgType) { 817 const Matcher< ::std::string> m1 = IsEmptyString(); 818 EXPECT_TRUE(m1.Matches("")); 819 820 const Matcher<const ::std::string&> m2 = IsEmptyStringByRef(); 821 EXPECT_TRUE(m2.Matches("")); 822} 823 824// Tests that MATCHER() can be used in a namespace. 825 826namespace matcher_test { 827MATCHER(IsOdd, "") { return (arg % 2) != 0; } 828} // namespace matcher_test 829 830TEST(MatcherMacroTest, WorksInNamespace) { 831 Matcher<int> m = matcher_test::IsOdd(); 832 EXPECT_FALSE(m.Matches(4)); 833 EXPECT_TRUE(m.Matches(5)); 834} 835 836// Tests that Value() can be used to compose matchers. 837MATCHER(IsPositiveOdd, "") { 838 return Value(arg, matcher_test::IsOdd()) && arg > 0; 839} 840 841TEST(MatcherMacroTest, CanBeComposedUsingValue) { 842 EXPECT_THAT(3, IsPositiveOdd()); 843 EXPECT_THAT(4, Not(IsPositiveOdd())); 844 EXPECT_THAT(-1, Not(IsPositiveOdd())); 845} 846 847// Tests that a simple MATCHER_P() definition works. 848 849MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; } 850 851TEST(MatcherPMacroTest, Works) { 852 const Matcher<int> m = IsGreaterThan32And(5); 853 EXPECT_TRUE(m.Matches(36)); 854 EXPECT_FALSE(m.Matches(5)); 855 856 EXPECT_EQ("is greater than 32 and 5", Describe(m)); 857 EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m)); 858 EXPECT_EQ("", Explain(m, 36)); 859 EXPECT_EQ("", Explain(m, 5)); 860} 861 862// Tests that the description is calculated correctly from the matcher name. 863MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; } 864 865TEST(MatcherPMacroTest, GeneratesCorrectDescription) { 866 const Matcher<int> m = _is_Greater_Than32and_(5); 867 868 EXPECT_EQ("is greater than 32 and 5", Describe(m)); 869 EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m)); 870 EXPECT_EQ("", Explain(m, 36)); 871 EXPECT_EQ("", Explain(m, 5)); 872} 873 874// Tests that a MATCHER_P matcher can be explicitly instantiated with 875// a reference parameter type. 876 877class UncopyableFoo { 878 public: 879 explicit UncopyableFoo(char value) : value_(value) {} 880 private: 881 UncopyableFoo(const UncopyableFoo&); 882 void operator=(const UncopyableFoo&); 883 884 char value_; 885}; 886 887MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; } 888 889TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) { 890 UncopyableFoo foo1('1'), foo2('2'); 891 const Matcher<const UncopyableFoo&> m = 892 ReferencesUncopyable<const UncopyableFoo&>(foo1); 893 894 EXPECT_TRUE(m.Matches(foo1)); 895 EXPECT_FALSE(m.Matches(foo2)); 896 897 // We don't want the address of the parameter printed, as most 898 // likely it will just annoy the user. If the address is 899 // interesting, the user should consider passing the parameter by 900 // pointer instead. 901 EXPECT_EQ("references uncopyable 1-byte object <31>", Describe(m)); 902} 903 904 905// Tests that the body of MATCHER_Pn() can reference the parameter 906// types. 907 908MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") { 909 StaticAssertTypeEq<int, foo_type>(); 910 StaticAssertTypeEq<long, bar_type>(); // NOLINT 911 StaticAssertTypeEq<char, baz_type>(); 912 return arg == 0; 913} 914 915TEST(MatcherPnMacroTest, CanReferenceParamTypes) { 916 EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a')); 917} 918 919// Tests that a MATCHER_Pn matcher can be explicitly instantiated with 920// reference parameter types. 921 922MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") { 923 return &arg == &variable1 || &arg == &variable2; 924} 925 926TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) { 927 UncopyableFoo foo1('1'), foo2('2'), foo3('3'); 928 const Matcher<const UncopyableFoo&> m = 929 ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2); 930 931 EXPECT_TRUE(m.Matches(foo1)); 932 EXPECT_TRUE(m.Matches(foo2)); 933 EXPECT_FALSE(m.Matches(foo3)); 934} 935 936TEST(MatcherPnMacroTest, 937 GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) { 938 UncopyableFoo foo1('1'), foo2('2'); 939 const Matcher<const UncopyableFoo&> m = 940 ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2); 941 942 // We don't want the addresses of the parameters printed, as most 943 // likely they will just annoy the user. If the addresses are 944 // interesting, the user should consider passing the parameters by 945 // pointers instead. 946 EXPECT_EQ("references any of (1-byte object <31>, 1-byte object <32>)", 947 Describe(m)); 948} 949 950// Tests that a simple MATCHER_P2() definition works. 951 952MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; } 953 954TEST(MatcherPnMacroTest, Works) { 955 const Matcher<const long&> m = IsNotInClosedRange(10, 20); // NOLINT 956 EXPECT_TRUE(m.Matches(36L)); 957 EXPECT_FALSE(m.Matches(15L)); 958 959 EXPECT_EQ("is not in closed range (10, 20)", Describe(m)); 960 EXPECT_EQ("not (is not in closed range (10, 20))", DescribeNegation(m)); 961 EXPECT_EQ("", Explain(m, 36L)); 962 EXPECT_EQ("", Explain(m, 15L)); 963} 964 965// Tests that MATCHER*() definitions can be overloaded on the number 966// of parameters; also tests MATCHER_Pn() where n >= 3. 967 968MATCHER(EqualsSumOf, "") { return arg == 0; } 969MATCHER_P(EqualsSumOf, a, "") { return arg == a; } 970MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; } 971MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; } 972MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; } 973MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; } 974MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") { 975 return arg == a + b + c + d + e + f; 976} 977MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") { 978 return arg == a + b + c + d + e + f + g; 979} 980MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") { 981 return arg == a + b + c + d + e + f + g + h; 982} 983MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") { 984 return arg == a + b + c + d + e + f + g + h + i; 985} 986MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") { 987 return arg == a + b + c + d + e + f + g + h + i + j; 988} 989 990TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) { 991 EXPECT_THAT(0, EqualsSumOf()); 992 EXPECT_THAT(1, EqualsSumOf(1)); 993 EXPECT_THAT(12, EqualsSumOf(10, 2)); 994 EXPECT_THAT(123, EqualsSumOf(100, 20, 3)); 995 EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4)); 996 EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5)); 997 EXPECT_THAT("abcdef", 998 EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')); 999 EXPECT_THAT("abcdefg", 1000 EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g')); 1001 EXPECT_THAT("abcdefgh", 1002 EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 1003 "h")); 1004 EXPECT_THAT("abcdefghi", 1005 EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 1006 "h", 'i')); 1007 EXPECT_THAT("abcdefghij", 1008 EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 1009 "h", 'i', ::std::string("j"))); 1010 1011 EXPECT_THAT(1, Not(EqualsSumOf())); 1012 EXPECT_THAT(-1, Not(EqualsSumOf(1))); 1013 EXPECT_THAT(-12, Not(EqualsSumOf(10, 2))); 1014 EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3))); 1015 EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4))); 1016 EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5))); 1017 EXPECT_THAT("abcdef ", 1018 Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'))); 1019 EXPECT_THAT("abcdefg ", 1020 Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 1021 'g'))); 1022 EXPECT_THAT("abcdefgh ", 1023 Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 1024 "h"))); 1025 EXPECT_THAT("abcdefghi ", 1026 Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 1027 "h", 'i'))); 1028 EXPECT_THAT("abcdefghij ", 1029 Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', 1030 "h", 'i', ::std::string("j")))); 1031} 1032 1033// Tests that a MATCHER_Pn() definition can be instantiated with any 1034// compatible parameter types. 1035TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) { 1036 EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3))); 1037 EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d")); 1038 1039 EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3)))); 1040 EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d"))); 1041} 1042 1043// Tests that the matcher body can promote the parameter types. 1044 1045MATCHER_P2(EqConcat, prefix, suffix, "") { 1046 // The following lines promote the two parameters to desired types. 1047 std::string prefix_str(prefix); 1048 char suffix_char = static_cast<char>(suffix); 1049 return arg == prefix_str + suffix_char; 1050} 1051 1052TEST(MatcherPnMacroTest, SimpleTypePromotion) { 1053 Matcher<std::string> no_promo = 1054 EqConcat(std::string("foo"), 't'); 1055 Matcher<const std::string&> promo = 1056 EqConcat("foo", static_cast<int>('t')); 1057 EXPECT_FALSE(no_promo.Matches("fool")); 1058 EXPECT_FALSE(promo.Matches("fool")); 1059 EXPECT_TRUE(no_promo.Matches("foot")); 1060 EXPECT_TRUE(promo.Matches("foot")); 1061} 1062 1063// Verifies the type of a MATCHER*. 1064 1065TEST(MatcherPnMacroTest, TypesAreCorrect) { 1066 // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable. 1067 EqualsSumOfMatcher a0 = EqualsSumOf(); 1068 1069 // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable. 1070 EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1); 1071 1072 // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk 1073 // variable, and so on. 1074 EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2'); 1075 EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3'); 1076 EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4'); 1077 EqualsSumOfMatcherP5<int, int, int, int, char> a5 = 1078 EqualsSumOf(1, 2, 3, 4, '5'); 1079 EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 = 1080 EqualsSumOf(1, 2, 3, 4, 5, '6'); 1081 EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 = 1082 EqualsSumOf(1, 2, 3, 4, 5, 6, '7'); 1083 EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 = 1084 EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8'); 1085 EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 = 1086 EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9'); 1087 EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 = 1088 EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0'); 1089 1090 // Avoid "unused variable" warnings. 1091 (void)a0; 1092 (void)a1; 1093 (void)a2; 1094 (void)a3; 1095 (void)a4; 1096 (void)a5; 1097 (void)a6; 1098 (void)a7; 1099 (void)a8; 1100 (void)a9; 1101 (void)a10; 1102} 1103 1104// Tests that matcher-typed parameters can be used in Value() inside a 1105// MATCHER_Pn definition. 1106 1107// Succeeds if arg matches exactly 2 of the 3 matchers. 1108MATCHER_P3(TwoOf, m1, m2, m3, "") { 1109 const int count = static_cast<int>(Value(arg, m1)) 1110 + static_cast<int>(Value(arg, m2)) + static_cast<int>(Value(arg, m3)); 1111 return count == 2; 1112} 1113 1114TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) { 1115 EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10))); 1116 EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0)))); 1117} 1118 1119// Tests Contains(). 1120 1121TEST(ContainsTest, ListMatchesWhenElementIsInContainer) { 1122 list<int> some_list; 1123 some_list.push_back(3); 1124 some_list.push_back(1); 1125 some_list.push_back(2); 1126 EXPECT_THAT(some_list, Contains(1)); 1127 EXPECT_THAT(some_list, Contains(Gt(2.5))); 1128 EXPECT_THAT(some_list, Contains(Eq(2.0f))); 1129 1130 list<std::string> another_list; 1131 another_list.push_back("fee"); 1132 another_list.push_back("fie"); 1133 another_list.push_back("foe"); 1134 another_list.push_back("fum"); 1135 EXPECT_THAT(another_list, Contains(std::string("fee"))); 1136} 1137 1138TEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) { 1139 list<int> some_list; 1140 some_list.push_back(3); 1141 some_list.push_back(1); 1142 EXPECT_THAT(some_list, Not(Contains(4))); 1143} 1144 1145TEST(ContainsTest, SetMatchesWhenElementIsInContainer) { 1146 set<int> some_set; 1147 some_set.insert(3); 1148 some_set.insert(1); 1149 some_set.insert(2); 1150 EXPECT_THAT(some_set, Contains(Eq(1.0))); 1151 EXPECT_THAT(some_set, Contains(Eq(3.0f))); 1152 EXPECT_THAT(some_set, Contains(2)); 1153 1154 set<const char*> another_set; 1155 another_set.insert("fee"); 1156 another_set.insert("fie"); 1157 another_set.insert("foe"); 1158 another_set.insert("fum"); 1159 EXPECT_THAT(another_set, Contains(Eq(std::string("fum")))); 1160} 1161 1162TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) { 1163 set<int> some_set; 1164 some_set.insert(3); 1165 some_set.insert(1); 1166 EXPECT_THAT(some_set, Not(Contains(4))); 1167 1168 set<const char*> c_string_set; 1169 c_string_set.insert("hello"); 1170 EXPECT_THAT(c_string_set, Not(Contains(std::string("hello").c_str()))); 1171} 1172 1173TEST(ContainsTest, ExplainsMatchResultCorrectly) { 1174 const int a[2] = { 1, 2 }; 1175 Matcher<const int (&)[2]> m = Contains(2); 1176 EXPECT_EQ("whose element #1 matches", Explain(m, a)); 1177 1178 m = Contains(3); 1179 EXPECT_EQ("", Explain(m, a)); 1180 1181 m = Contains(GreaterThan(0)); 1182 EXPECT_EQ("whose element #0 matches, which is 1 more than 0", Explain(m, a)); 1183 1184 m = Contains(GreaterThan(10)); 1185 EXPECT_EQ("", Explain(m, a)); 1186} 1187 1188TEST(ContainsTest, DescribesItselfCorrectly) { 1189 Matcher<vector<int> > m = Contains(1); 1190 EXPECT_EQ("contains at least one element that is equal to 1", Describe(m)); 1191 1192 Matcher<vector<int> > m2 = Not(m); 1193 EXPECT_EQ("doesn't contain any element that is equal to 1", Describe(m2)); 1194} 1195 1196TEST(ContainsTest, MapMatchesWhenElementIsInContainer) { 1197 map<const char*, int> my_map; 1198 const char* bar = "a string"; 1199 my_map[bar] = 2; 1200 EXPECT_THAT(my_map, Contains(pair<const char* const, int>(bar, 2))); 1201 1202 map<std::string, int> another_map; 1203 another_map["fee"] = 1; 1204 another_map["fie"] = 2; 1205 another_map["foe"] = 3; 1206 another_map["fum"] = 4; 1207 EXPECT_THAT(another_map, 1208 Contains(pair<const std::string, int>(std::string("fee"), 1))); 1209 EXPECT_THAT(another_map, Contains(pair<const std::string, int>("fie", 2))); 1210} 1211 1212TEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) { 1213 map<int, int> some_map; 1214 some_map[1] = 11; 1215 some_map[2] = 22; 1216 EXPECT_THAT(some_map, Not(Contains(pair<const int, int>(2, 23)))); 1217} 1218 1219TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) { 1220 const char* string_array[] = { "fee", "fie", "foe", "fum" }; 1221 EXPECT_THAT(string_array, Contains(Eq(std::string("fum")))); 1222} 1223 1224TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) { 1225 int int_array[] = { 1, 2, 3, 4 }; 1226 EXPECT_THAT(int_array, Not(Contains(5))); 1227} 1228 1229TEST(ContainsTest, AcceptsMatcher) { 1230 const int a[] = { 1, 2, 3 }; 1231 EXPECT_THAT(a, Contains(Gt(2))); 1232 EXPECT_THAT(a, Not(Contains(Gt(4)))); 1233} 1234 1235TEST(ContainsTest, WorksForNativeArrayAsTuple) { 1236 const int a[] = { 1, 2 }; 1237 const int* const pointer = a; 1238 EXPECT_THAT(make_tuple(pointer, 2), Contains(1)); 1239 EXPECT_THAT(make_tuple(pointer, 2), Not(Contains(Gt(3)))); 1240} 1241 1242TEST(ContainsTest, WorksForTwoDimensionalNativeArray) { 1243 int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; 1244 EXPECT_THAT(a, Contains(ElementsAre(4, 5, 6))); 1245 EXPECT_THAT(a, Contains(Contains(5))); 1246 EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5)))); 1247 EXPECT_THAT(a, Contains(Not(Contains(5)))); 1248} 1249 1250TEST(AllOfTest, HugeMatcher) { 1251 // Verify that using AllOf with many arguments doesn't cause 1252 // the compiler to exceed template instantiation depth limit. 1253 EXPECT_THAT(0, testing::AllOf(_, _, _, _, _, _, _, _, _, 1254 testing::AllOf(_, _, _, _, _, _, _, _, _, _))); 1255} 1256 1257TEST(AnyOfTest, HugeMatcher) { 1258 // Verify that using AnyOf with many arguments doesn't cause 1259 // the compiler to exceed template instantiation depth limit. 1260 EXPECT_THAT(0, testing::AnyOf(_, _, _, _, _, _, _, _, _, 1261 testing::AnyOf(_, _, _, _, _, _, _, _, _, _))); 1262} 1263 1264namespace adl_test { 1265 1266// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf 1267// don't issue unqualified recursive calls. If they do, the argument dependent 1268// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found 1269// as a candidate and the compilation will break due to an ambiguous overload. 1270 1271// The matcher must be in the same namespace as AllOf/AnyOf to make argument 1272// dependent lookup find those. 1273MATCHER(M, "") { return true; } 1274 1275template <typename T1, typename T2> 1276bool AllOf(const T1& t1, const T2& t2) { return true; } 1277 1278TEST(AllOfTest, DoesNotCallAllOfUnqualified) { 1279 EXPECT_THAT(42, testing::AllOf( 1280 M(), M(), M(), M(), M(), M(), M(), M(), M(), M())); 1281} 1282 1283template <typename T1, typename T2> bool 1284AnyOf(const T1& t1, const T2& t2) { return true; } 1285 1286TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) { 1287 EXPECT_THAT(42, testing::AnyOf( 1288 M(), M(), M(), M(), M(), M(), M(), M(), M(), M())); 1289} 1290 1291} // namespace adl_test 1292 1293#ifdef _MSC_VER 1294# pragma warning(pop) 1295#endif 1296 1297#if GTEST_LANG_CXX11 1298 1299TEST(AllOfTest, WorksOnMoveOnlyType) { 1300 std::unique_ptr<int> p(new int(3)); 1301 EXPECT_THAT(p, AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(5)))); 1302 EXPECT_THAT(p, Not(AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(3))))); 1303} 1304 1305TEST(AnyOfTest, WorksOnMoveOnlyType) { 1306 std::unique_ptr<int> p(new int(3)); 1307 EXPECT_THAT(p, AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Lt(5)))); 1308 EXPECT_THAT(p, Not(AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Gt(5))))); 1309} 1310 1311MATCHER(IsNotNull, "") { 1312 return arg != nullptr; 1313} 1314 1315// Verifies that a matcher defined using MATCHER() can work on 1316// move-only types. 1317TEST(MatcherMacroTest, WorksOnMoveOnlyType) { 1318 std::unique_ptr<int> p(new int(3)); 1319 EXPECT_THAT(p, IsNotNull()); 1320 EXPECT_THAT(std::unique_ptr<int>(), Not(IsNotNull())); 1321} 1322 1323MATCHER_P(UniquePointee, pointee, "") { 1324 return *arg == pointee; 1325} 1326 1327// Verifies that a matcher defined using MATCHER_P*() can work on 1328// move-only types. 1329TEST(MatcherPMacroTest, WorksOnMoveOnlyType) { 1330 std::unique_ptr<int> p(new int(3)); 1331 EXPECT_THAT(p, UniquePointee(3)); 1332 EXPECT_THAT(p, Not(UniquePointee(2))); 1333} 1334 1335#endif // GTEST_LASNG_CXX11 1336 1337} // namespace 1338 1339#ifdef _MSC_VER 1340# pragma warning(pop) 1341#endif 1342