3rdparty/googletest/googlemock/test/gmock-generated-matchers_test.cc

   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
  57 namespace {
  58
  59 using std::list;
  60 using std::map;
  61 using std::pair;
  62 using std::set;
  63 using std::stringstream;
  64 using std::vector;
  65 using testing::get;
  66 using testing::make_tuple;
  67 using testing::tuple;
  68 using testing::_;
  69 using testing::AllOf;
  70 using testing::AnyOf;
  71 using testing::Args;
  72 using testing::Contains;
  73 using testing::ElementsAre;
  74 using testing::ElementsAreArray;
  75 using testing::Eq;
  76 using testing::Ge;
  77 using testing::Gt;
  78 using testing::Le;
  79 using testing::Lt;
  80 using testing::MakeMatcher;
  81 using testing::Matcher;
  82 using testing::MatcherInterface;
  83 using testing::MatchResultListener;
  84 using testing::Ne;
  85 using testing::Not;
  86 using testing::Pointee;
  87 using testing::PrintToString;
  88 using testing::Ref;
  89 using testing::StaticAssertTypeEq;
  90 using testing::StrEq;
  91 using testing::Value;
  92 using testing::internal::ElementsAreArrayMatcher;
  93
  94 // Returns the description of the given matcher.
  95 template <typename T>
  96 std::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.
 103 template <typename T>
 104 std::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.
 111 template <typename MatcherType, typename Value>
 112 std::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
 120 TEST(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
 126 TEST(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
 133 TEST(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
 141 TEST(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
 147 TEST(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
 163 MATCHER(SumIsZero, "") {
 164   return get<0>(arg) + get<1>(arg) + get<2>(arg) == 0;
 165 }
 166
 167 TEST(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
 172 TEST(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
 178 TEST(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
 185 TEST(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.
 193 MATCHER_P(PrintsAs, str, "") {
 194   return testing::PrintToString(arg) == str;
 195 }
 196
 197 TEST(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
 206 TEST(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
 213 TEST(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
 221 TEST(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
 228 TEST(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.
 237 class 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
 252 Matcher<tuple<char, int> > LessThan() {
 253   return MakeMatcher(new LessThanMatcher);
 254 }
 255
 256 TEST(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().
 266 class 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
 292 Matcher<int> GreaterThan(int n) {
 293   return MakeMatcher(new GreaterThanMatcher(n));
 294 }
 295
 296 // Tests for ElementsAre().
 297
 298 TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
 299   Matcher<const vector<int>&> m = ElementsAre();
 300   EXPECT_EQ("is empty", Describe(m));
 301 }
 302
 303 TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
 304   Matcher<vector<int> > m = ElementsAre(Gt(5));
 305   EXPECT_EQ("has 1 element that is > 5", Describe(m));
 306 }
 307
 308 TEST(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
 315 TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
 316   Matcher<vector<int> > m = ElementsAre();
 317   EXPECT_EQ("isn't empty", DescribeNegation(m));
 318 }
 319
 320 TEST(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
 326 TEST(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
 333 TEST(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
 342 TEST(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
 353 TEST(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
 364 TEST(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
 377 TEST(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
 384 TEST(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
 391 TEST(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
 400 TEST(ElementsAreTest, MatchesOneElementEqMatcher) {
 401   vector<int> test_vector;
 402   test_vector.push_back(4);
 403
 404   EXPECT_THAT(test_vector, ElementsAre(Eq(4)));
 405 }
 406
 407 TEST(ElementsAreTest, MatchesOneElementAnyMatcher) {
 408   vector<int> test_vector;
 409   test_vector.push_back(4);
 410
 411   EXPECT_THAT(test_vector, ElementsAre(_));
 412 }
 413
 414 TEST(ElementsAreTest, MatchesOneElementValue) {
 415   vector<int> test_vector;
 416   test_vector.push_back(4);
 417
 418   EXPECT_THAT(test_vector, ElementsAre(4));
 419 }
 420
 421 TEST(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
 430 TEST(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
 440 TEST(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
 449 TEST(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
 457 TEST(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
 468 TEST(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
 485 TEST(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
 493 TEST(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
 501 TEST(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
 508 class 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
 518 TEST(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
 530 TEST(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
 539 TEST(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.
 553 extern const char kHi[];
 554
 555 TEST(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
 566 const char kHi[] = "hi";
 567
 568 #endif  // _MSC_VER
 569
 570 TEST(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
 589 TEST(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
 599 TEST(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
 610 TEST(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
 620 TEST(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
 634 TEST(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
 645 TEST(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
 652 TEST(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
 659 TEST(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
 667 TEST(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
 681 TEST(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
 692 TEST(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.
 707 TEST(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
 716 TEST(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
 736 MATCHER(IsEven, "") { return (arg % 2) == 0; }
 737
 738 TEST(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'.
 750 MATCHER(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.
 764 MATCHER_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.
 782 TEST(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.
 793 TEST(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
 806 MATCHER(IsEmptyString, "") {
 807   StaticAssertTypeEq< ::std::string, arg_type>();
 808   return arg == "";
 809 }
 810
 811 MATCHER(IsEmptyStringByRef, "") {
 812   StaticAssertTypeEq<const ::std::string&, arg_type>();
 813   return arg == "";
 814 }
 815
 816 TEST(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
 826 namespace matcher_test {
 827 MATCHER(IsOdd, "") { return (arg % 2) != 0; }
 828 }  // namespace matcher_test
 829
 830 TEST(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.
 837 MATCHER(IsPositiveOdd, "") {
 838   return Value(arg, matcher_test::IsOdd()) && arg > 0;
 839 }
 840
 841 TEST(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
 849 MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; }
 850
 851 TEST(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.
 863 MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }
 864
 865 TEST(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
 877 class 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
 887 MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; }
 888
 889 TEST(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
 908 MATCHER_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
 915 TEST(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
 922 MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") {
 923   return &arg == &variable1 || &arg == &variable2;
 924 }
 925
 926 TEST(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
 936 TEST(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
 952 MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; }
 953
 954 TEST(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
 968 MATCHER(EqualsSumOf, "") { return arg == 0; }
 969 MATCHER_P(EqualsSumOf, a, "") { return arg == a; }
 970 MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; }
 971 MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; }
 972 MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; }
 973 MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; }
 974 MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") {
 975   return arg == a + b + c + d + e + f;
 976 }
 977 MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") {
 978   return arg == a + b + c + d + e + f + g;
 979 }
 980 MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") {
 981   return arg == a + b + c + d + e + f + g + h;
 982 }
 983 MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") {
 984   return arg == a + b + c + d + e + f + g + h + i;
 985 }
 986 MATCHER_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
 990 TEST(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.
1035 TEST(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
1045 MATCHER_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
1052 TEST(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
1065 TEST(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.
1108 MATCHER_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
1114 TEST(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
1121 TEST(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
1138 TEST(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
1145 TEST(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
1162 TEST(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
1173 TEST(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
1188 TEST(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
1196 TEST(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
1212 TEST(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
1219 TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) {
1220   const char* string_array[] = { "fee", "fie", "foe", "fum" };
1221   EXPECT_THAT(string_array, Contains(Eq(std::string("fum"))));
1222 }
1223
1224 TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) {
1225   int int_array[] = { 1, 2, 3, 4 };
1226   EXPECT_THAT(int_array, Not(Contains(5)));
1227 }
1228
1229 TEST(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
1235 TEST(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
1242 TEST(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
1250 TEST(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
1257 TEST(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
1264 namespace 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.
1273 MATCHER(M, "") { return true; }
1274
1275 template <typename T1, typename T2>
1276 bool AllOf(const T1& t1, const T2& t2) { return true; }
1277
1278 TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
1279   EXPECT_THAT(42, testing::AllOf(
1280       M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
1281 }
1282
1283 template <typename T1, typename T2> bool
1284 AnyOf(const T1& t1, const T2& t2) { return true; }
1285
1286 TEST(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
1299 TEST(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
1305 TEST(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
1311 MATCHER(IsNotNull, "") {
1312   return arg != nullptr;
1313 }
1314
1315 // Verifies that a matcher defined using MATCHER() can work on
1316 // move-only types.
1317 TEST(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
1323 MATCHER_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.
1329 TEST(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