googlemock/test/gmock-matchers_test.cc

107 using testing::Matcher;
188 Matcher<int> GreaterThan(int n) {
202 string Describe(const Matcher<T>& m) {
210 string DescribeNegation(const Matcher<T>& m) {
300   Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
309   Matcher<double> m;
312 // Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
315   Matcher<int> m(impl);
322   Matcher<int> m1 = 5;
329   Matcher<int*> m1 = NULL;
338   Matcher<bool> m1 = Eq(false);
348 // Tests that Matcher<T>::DescribeTo() calls
352             Describe(Matcher<int>(new EvenMatcherImpl)));
355 // Tests Matcher<T>::MatchAndExplain().
357   Matcher<int> m = GreaterThan(0);
368 // Matcher<string> or Matcher<const string&>.
370   Matcher<string> m1 = "hi";
374   Matcher<const string&> m2 = "hi";
380 // Matcher<string> or Matcher<const string&>.
382   Matcher<string> m1 = string("hi");
386   Matcher<const string&> m2 = string("hi");
393 // Matcher<StringPiece> or Matcher<const StringPiece&>.
395   Matcher<StringPiece> m1 = "cats";
399   Matcher<const StringPiece&> m2 = "cats";
405 // Matcher<StringPiece> or Matcher<const StringPiece&>.
407   Matcher<StringPiece> m1 = string("cats");
411   Matcher<const StringPiece&> m2 = string("cats");
417 // Matcher<StringPiece> or Matcher<const StringPiece&>.
419   Matcher<StringPiece> m1 = StringPiece("cats");
423   Matcher<const StringPiece&> m2 = StringPiece("cats");
429 // Tests that MakeMatcher() constructs a Matcher<T> from a
434   Matcher<int> m = MakeMatcher(dummy_impl);
464   Matcher<const int&> m1 = ReferencesBarOrIsZero();
472   Matcher<double> m2 = ReferencesBarOrIsZero();
506   // Using PolymorphicIsEven() as a Matcher<int>.
507   const Matcher<int> m1 = PolymorphicIsEven();
512   const Matcher<int> not_m1 = Not(m1);
517   // Using PolymorphicIsEven() as a Matcher<char>.
518   const Matcher<char> m2 = PolymorphicIsEven();
523   const Matcher<char> not_m2 = Not(m2);
531   Matcher<int> m = MatcherCast<int>(Eq(5));
553 // Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
556   Matcher<double> m1 = Eq(2.0);
557   Matcher<int> m2 = MatcherCast<int>(m1);
561   Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
562   Matcher<int> m4 = MatcherCast<int>(m3);
570 // Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
572   Matcher<const int&> m1 = Eq(0);
573   Matcher<int> m2 = MatcherCast<int>(m1);
578 // Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
580   Matcher<int&> m1 = Eq(0);
581   Matcher<int> m2 = MatcherCast<int>(m1);
586 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
588   Matcher<int> m1 = Eq(0);
589   Matcher<const int&> m2 = MatcherCast<const int&>(m1);
594 // Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
596   Matcher<int> m1 = Eq(0);
597   Matcher<int&> m2 = MatcherCast<int&>(m1);
604 // Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
606   Matcher<int> m1 = Eq(0);
607   Matcher<int> m2 = MatcherCast<int>(m1);
631   Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
637   Matcher<ConvertibleFromAny> m =
654   Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
677   Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
682 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
686   Matcher<double> m1 = DoubleEq(1.0);
687   Matcher<float> m2 = SafeMatcherCast<float>(m1);
691   Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
696 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
700   Matcher<Base*> m1 = Eq(&d);
701   Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
705   Matcher<Base&> m3 = Ref(d);
706   Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
711 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
714   Matcher<const int&> m1 = Ref(n);
715   Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
721 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
723   Matcher<int> m1 = Eq(0);
724   Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
729 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
731   Matcher<int> m1 = Eq(0);
732   Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
739 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
741   Matcher<int> m1 = Eq(0);
742   Matcher<int> m2 = SafeMatcherCast<int>(m1);
748   Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
754   Matcher<ConvertibleFromAny> m =
762   Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
785   Matcher<double> m1 = A<double>();
792   Matcher<int&> m2 = A<int&>();
814   Matcher<int> m1 = An<int>();
821   Matcher<int&> m2 = An<int&>();
835   Matcher<int> m1 = _;
842   Matcher<const bool&> m2 = _;
849   Matcher<int> m = _;
859   Matcher<const char*> m1 = Eq(a1);
880   Matcher<Unprintable> m = Eq(Unprintable());
887   Matcher<int> m1 = Eq(1);
891   Matcher<char> m2 = Eq(1);
898   Matcher<char> m1 = TypedEq<char>('a');
902   Matcher<int> m2 = TypedEq<int>(6);
912 // Tests that TypedEq<T>(v) has type Matcher<T>.
927   // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
928   Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5));
929   Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5));
934   Matcher<int> m1 = Ge(0);
942   Matcher<int> m = Ge(5);
948   Matcher<double> m1 = Gt(0);
956   Matcher<int> m = Gt(5);
962   Matcher<char> m1 = Le('b');
970   Matcher<int> m = Le(5);
976   Matcher<const string&> m1 = Lt("Hello");
984   Matcher<int> m = Lt(5);
990   Matcher<int> m1 = Ne(0);
998   Matcher<int> m = Ne(5);
1004   Matcher<int*> m1 = IsNull();
1010   Matcher<const char*> m2 = IsNull();
1018   // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)'
1019   // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing::
1024   Matcher<void*> m3 = IsNull();
1032   const Matcher<linked_ptr<int> > m = IsNull();
1041   const Matcher<const linked_ptr<double>&> m = IsNull();
1051   const Matcher<std::function<void()>> m = IsNull();
1060   Matcher<int*> m = IsNull();
1067   Matcher<int*> m1 = NotNull();
1073   Matcher<const char*> m2 = NotNull();
1080   const Matcher<linked_ptr<int> > m = NotNull();
1089   const Matcher<const linked_ptr<double>&> m = NotNull();
1099   const Matcher<std::function<void()>> m = NotNull();
1108   Matcher<int*> m = NotNull();
1117   Matcher<int&> m = Ref(a);
1125   Matcher<int&> m = Ref(n);
1136   Matcher<const int&> m = Ref(a);
1148   Matcher<const Base&> m1 = Ref(base);
1161   EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
1165   EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
1172   Matcher<const char*> m = StrEq(string("Hello"));
1177   Matcher<const string&> m2 = StrEq("Hello");
1183   Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
1189   Matcher<string> m2 = StrEq(str);
1192   Matcher<string> m3 = StrEq(str);
1197   Matcher<const char*> m = StrNe("Hello");
1202   Matcher<string> m2 = StrNe(string("Hello"));
1208   Matcher<const char*> m = StrNe("Hi");
1213   Matcher<const char*> m = StrCaseEq(string("Hello"));
1219   Matcher<const string&> m2 = StrCaseEq("Hello");
1227   Matcher<const string&> m0 = StrCaseEq(str1);
1231   Matcher<const string&> m1 = StrCaseEq(str1);
1236   Matcher<const string&> m2 = StrCaseEq(str1);
1240   Matcher<const string&> m3 = StrCaseEq(str1);
1250   Matcher<string> m = StrCaseEq("Hi");
1255   Matcher<const char*> m = StrCaseNe("Hello");
1261   Matcher<string> m2 = StrCaseNe(string("Hello"));
1267   Matcher<const char*> m = StrCaseNe("Hi");
1273   const Matcher<string> m1 = HasSubstr("foo");
1277   const Matcher<const std::string&> m2 = HasSubstr("foo");
1284   const Matcher<char*> m1 = HasSubstr("foo");
1289   const Matcher<const char*> m2 = HasSubstr("foo");
1297   Matcher<string> m = HasSubstr("foo\n\"");
1302   Matcher<const pair<std::string, int>&> m = Key("foo");
1308   Matcher<pair<int, bool> > m = Key(GreaterThan(10));
1324   Matcher<int> is_positive = Gt(0);
1325   Matcher<int> is_negative = Lt(0);
1358   Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
1359   Matcher<const pair<const char*, int> > m2 = Pair("foo", 42);
1360   Matcher<pair<const char*, int> > m3 = Pair("foo", 42);
1362   Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
1363   Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
1367   Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
1375   Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
1384   const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
1406   const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
1413   const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0));
1440   Matcher<int> is_positive = Gt(0);
1441   Matcher<int> is_negative = Lt(0);
1463   const Matcher<const char*> m1 = StartsWith(string(""));
1468   const Matcher<const string&> m2 = StartsWith("Hi");
1477   Matcher<const std::string> m = StartsWith("Hi");
1484   const Matcher<const char*> m1 = EndsWith("");
1489   const Matcher<const string&> m2 = EndsWith(string("Hi"));
1498   Matcher<const std::string> m = EndsWith("Hi");
1505   const Matcher<const char*> m1 = MatchesRegex("a.*z");
1510   const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z"));
1517   Matcher<const std::string> m1 = MatchesRegex(string("Hi.*"));
1520   Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
1527   const Matcher<const char*> m1 = ContainsRegex(string("a.*z"));
1532   const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z"));
1539   Matcher<const std::string> m1 = ContainsRegex("Hi.*");
1542   Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
1549   Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
1554   Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
1558   Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
1564   Matcher<const ::std::wstring&> m4 = StrEq(str);
1567   Matcher<const ::std::wstring&> m5 = StrEq(str);
1572   Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
1576   Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
1582   Matcher<const ::std::wstring&> m4 = StrEq(str);
1585   Matcher<const ::std::wstring&> m5 = StrEq(str);
1590   Matcher<const wchar_t*> m = StrNe(L"Hello");
1595   Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
1601   Matcher<const wchar_t*> m = StrNe(L"Hi");
1606   Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
1612   Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
1620   Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
1624   Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
1629   Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
1633   Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
1643   Matcher< ::std::wstring> m = StrCaseEq(L"Hi");
1648   Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
1654   Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
1660   Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
1666   const Matcher< ::std::wstring> m1 = HasSubstr(L"foo");
1670   const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
1677   const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
1682   const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
1690   Matcher< ::std::wstring> m = HasSubstr(L"foo\n\"");
1697   const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
1702   const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
1711   Matcher<const ::std::wstring> m = StartsWith(L"Hi");
1718   const Matcher<const wchar_t*> m1 = EndsWith(L"");
1723   const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
1732   Matcher<const ::std::wstring> m = EndsWith(L"Hi");
1740   Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello"));
1745   Matcher<const ::wstring&> m2 = StrEq(L"Hello");
1749   Matcher<const ::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
1755   Matcher<const ::wstring&> m4 = StrEq(str);
1758   Matcher<const ::wstring&> m5 = StrEq(str);
1763   Matcher< ::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
1767   Matcher< ::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
1773   Matcher<const ::wstring&> m4 = StrEq(str);
1776   Matcher<const ::wstring&> m5 = StrEq(str);
1781   Matcher<const wchar_t*> m = StrNe(L"Hello");
1786   Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello"));
1792   Matcher<const wchar_t*> m = StrNe(L"Hi");
1797   Matcher<const wchar_t*> m = StrCaseEq(::wstring(L"Hello"));
1803   Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello");
1811   Matcher<const ::wstring&> m0 = StrCaseEq(str1);
1815   Matcher<const ::wstring&> m1 = StrCaseEq(str1);
1820   Matcher<const ::wstring&> m2 = StrCaseEq(str1);
1824   Matcher<const ::wstring&> m3 = StrCaseEq(str1);
1834   Matcher< ::wstring> m = StrCaseEq(L"Hi");
1839   Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
1845   Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello"));
1851   Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
1857   const Matcher< ::wstring> m1 = HasSubstr(L"foo");
1861   const Matcher<const ::wstring&> m2 = HasSubstr(L"foo");
1868   const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
1873   const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
1881   Matcher< ::wstring> m = HasSubstr(L"foo\n\"");
1888   const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L""));
1893   const Matcher<const ::wstring&> m2 = StartsWith(L"Hi");
1902   Matcher<const ::wstring> m = StartsWith(L"Hi");
1909   const Matcher<const wchar_t*> m1 = EndsWith(L"");
1914   const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi"));
1923   Matcher<const ::wstring> m = EndsWith(L"Hi");
1935   Matcher<const Tuple2&> m = Eq();
1942   Matcher<const Tuple2&> m = Eq();
1949   Matcher<const Tuple2&> m = Ge();
1957   Matcher<const Tuple2&> m = Ge();
1964   Matcher<const Tuple2&> m = Gt();
1972   Matcher<const Tuple2&> m = Gt();
1979   Matcher<const Tuple2&> m = Le();
1987   Matcher<const Tuple2&> m = Le();
1994   Matcher<const Tuple2&> m = Lt();
2002   Matcher<const Tuple2&> m = Lt();
2009   Matcher<const Tuple2&> m = Ne();
2017   Matcher<const Tuple2&> m = Ne();
2023   Matcher<int> m;
2031   Matcher<int> m = Not(Eq(5));
2038   Matcher<int> greater_than_5 = Gt(5);
2040   Matcher<const int&> m = Not(greater_than_5);
2041   Matcher<int&> m2 = Not(greater_than_5);
2042   Matcher<int&> m3 = Not(m);
2046 void AllOfMatches(int num, const Matcher<int>& m) {
2058   Matcher<int> m;
2107   Matcher<int> m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
2125   Matcher<int> m;
2155   Matcher<int> m;
2188   Matcher<int> greater_than_5 = Gt(5);
2189   Matcher<int> less_than_10 = Lt(10);
2191   Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
2192   Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
2193   Matcher<int&> m3 = AllOf(greater_than_5, m2);
2196   Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
2197   Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
2201   Matcher<int> m;
2244 void AnyOfMatches(int num, const Matcher<int>& m) {
2256   Matcher<int> m;
2301   Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
2316   Matcher<int> m;
2344   Matcher<int> m;
2373   Matcher<int> greater_than_5 = Gt(5);
2374   Matcher<int> less_than_10 = Lt(10);
2376   Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
2377   Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
2378   Matcher<int&> m3 = AnyOf(greater_than_5, m2);
2381   Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
2382   Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
2386   Matcher<int> m;
2463   Matcher<double> m = Truly(IsPositive);
2470   Matcher<int> m = Truly(IsGreaterThan(5));
2493   Matcher<int> m = Truly(IsNotZero);
2500   Matcher<double> m = Truly(IsPositive);
2508   Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
2529 // Tests that a Matcher on non-reference type can be used in
2532   Matcher<int> eq5 = Eq(5);
2546   const Matcher<int> is_zero = Eq(0);
2551   const Matcher<const int&> ref_n = Ref(n);
2567   const Matcher<int> is_even = PolymorphicIsEven();
2572   const Matcher<const double&> is_zero = Eq(0);
2685   Matcher<const char*> starts_with_he = StartsWith("he");
2688   Matcher<const string&> ends_with_ok = EndsWith("ok");
2695   Matcher<int> is_greater_than_5 = Gt(5);
2737     Matcher<RawType> m1 = matcher_maker(0.0);
2743     Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_);
2746     Matcher<RawType> m3 = matcher_maker(1.0);
2753     Matcher<RawType> m4 = matcher_maker(-infinity_);
2756     Matcher<RawType> m5 = matcher_maker(infinity_);
2763     // matcher_maker can produce a Matcher<const RawType&>, which is needed in
2765     Matcher<const RawType&> m6 = matcher_maker(0.0);
2770     // matcher_maker can produce a Matcher<RawType&>, which is needed in some
2772     Matcher<RawType&> m7 = matcher_maker(0.0);
2826     Matcher<RawType> m1 = matcher_maker(0.0, 0.0);
2833     Matcher<RawType> m2 = matcher_maker(0.0, 1.0);
2843     Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0);
2848     Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0);
2854     Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
2858     Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
2862     Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
2866     Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
2872     Matcher<RawType> m9 = matcher_maker(
2876     // matcher_maker can produce a Matcher<const RawType&>, which is needed in
2878     Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0);
2883     // matcher_maker can produce a Matcher<RawType&>, which is needed in some
2885     Matcher<RawType&> m11 = matcher_maker(0.0, 1.0);
2912   Matcher<float> m = FloatEq(nan1_);
2920   Matcher<float> m = NanSensitiveFloatEq(nan1_);
2927   Matcher<float> m1 = FloatEq(2.0f);
2931   Matcher<float> m2 = FloatEq(0.5f);
2935   Matcher<float> m3 = FloatEq(nan1_);
2941   Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
2945   Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
2949   Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
2967   Matcher<float> m1 = FloatNear(2.0f, 0.5f);
2972   Matcher<float> m2 = FloatNear(0.5f, 0.5f);
2977   Matcher<float> m3 = FloatNear(nan1_, 0.0);
2983   Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
2988   Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
2993   Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
3000   Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
3008   Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
3027   Matcher<double> m = DoubleEq(nan1_);
3035   Matcher<double> m = NanSensitiveDoubleEq(nan1_);
3042   Matcher<double> m1 = DoubleEq(2.0);
3046   Matcher<double> m2 = DoubleEq(0.5);
3050   Matcher<double> m3 = DoubleEq(nan1_);
3056   Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
3060   Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
3064   Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
3082   Matcher<double> m1 = DoubleNear(2.0, 0.5);
3087   Matcher<double> m2 = DoubleNear(0.5, 0.5);
3092   Matcher<double> m3 = DoubleNear(nan1_, 0.0);
3111   Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
3116   Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
3121   Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
3128   Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
3136   Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
3143   const Matcher<int*> m = Pointee(Ge(0));
3153   const Matcher<const double*> m = Pointee(Ge(0));
3163   const Matcher<int* const &> m = Pointee(Ge(0));
3173   const Matcher<double* &> m = Pointee(Ge(0));
3246   Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
3255   Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
3263   Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
3305   const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5));
3317   const Matcher<const char*> m = Pointee(_);
3323   const Matcher<int*> m = Pointee(5);
3333   const Matcher<int*> m = Pointee(Gt(3));
3340   const Matcher<const string*> m = Pointee(StartsWith("Hi"));
3344   const Matcher<long*> m2 = Pointee(GreaterThan(1));  // NOLINT
3351   const Matcher<int*> m = Pointee(0);
3402   Matcher<AStruct> m = Field(&AStruct::x, Ge(0));
3414   Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0));
3424   Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive));
3433   Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL));
3449   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
3462   Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0));
3474   Matcher<const AStruct&> m = Field(&AStruct::x,
3475                                     Matcher<signed char>(Ge(0)));
3485   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
3493   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
3507   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
3517   Matcher<AStruct*> m = Field(&AStruct::x, Ge(0));
3527   Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0));
3537   Matcher<const AStruct*> m = Field(&AStruct::x, _);
3546   Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0));
3556   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
3564   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
3614   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
3627   Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi"));
3643   Matcher<const AClass&> m = Property(&AClass::x, Ref(x));
3653   Matcher<AClass> m = Property(&AClass::s, StartsWith("hi"));
3668   Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0));
3682   Matcher<const AClass&> m = Property(&AClass::n,
3683                                       Matcher<signed char>(Ge(0)));
3693   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
3702   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
3716   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
3728   Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi"));
3741   Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi"));
3753   Matcher<const AClass*> m = Property(&AClass::x, _);
3762   Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0));
3774   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
3783   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
3805   Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo")));
3813   Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
3825   Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
3837   Matcher<int> matcher = ResultOf(&IntFunction, Eq(80));
3854   Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x));
3862   Matcher<Uncopyable&> matcher2 =
3876   Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s));
3886   Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85)));
3903   Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo"));
3917   Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo")));
3933   Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5));
3938   Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5));
3954   Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n));
3958   Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n));
3997   const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
4004   const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
4011   const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
4018   const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
4023   const Matcher<int> m = AllOf(Ge(2), Le(3));
4028   const Matcher<int> m = GreaterThan(5);
4057   const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
4066   const Matcher<NotCopyable&> m = Ge(ByRef(value2));
4092   Matcher<vector<int> > m = IsEmpty();
4098   Matcher<vector<int> > m = IsEmpty();
4131   Matcher<const vector<int>&> m = SizeIs(1);
4138   Matcher<vector<int> > m = SizeIs(2);
4144   Matcher<vector<int> > m1 = SizeIs(2);
4145   Matcher<vector<int> > m2 = SizeIs(Lt(2u));
4146   Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
4147   Matcher<vector<int> > m4 = SizeIs(GreaterThan(1));
4183   const Matcher<TypeParam> m = ContainerEq(my_set);
4194   const Matcher<TypeParam> m = ContainerEq(my_set);
4206   const Matcher<const TypeParam&> m = ContainerEq(my_set);
4217   const Matcher<TypeParam> m = ContainerEq(my_set);
4230   const Matcher<const TypeParam&> m = ContainerEq(my_set);
4244   const Matcher<vector<int> > m = ContainerEq(my_set);
4257   const Matcher<const list<size_t>&> m = ContainerEq(my_set);
4269   const Matcher<const list<size_t> > m = ContainerEq(my_set);
4283   const Matcher<vector<int> > m = ContainerEq(my_set);
4301   const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
4357   const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
4403   const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
4486     Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
4488     Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
4604   Matcher<vector<int> > m = BeginEndDistanceIs(2);
4611   Matcher<vector<int> > m1 = BeginEndDistanceIs(2);
4612   Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2));
4613   Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3));
4614   Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1));
4652   Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2, 3, 4, 5);
4785   EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int> >(
4787   EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int> >(
4819   std::vector<Matcher<int> > mv;
4848   std::vector<Matcher<int> > mv;
4864   std::vector<Matcher<int> > mv;
5301   ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
5306   ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
5315   ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
5328   Matcher<set<int> > m = Each(2);
5331   Matcher<const int(&)[1]> n = Each(1);  // NOLINT
5351   Matcher<vector<int> > m = Each(1);
5354   Matcher<vector<int> > m2 = Not(m);
5442   const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs);
5458   const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
5526   const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
5532   const Matcher<tuple<double, int> > m2 = IsHalfOf();
5542   const Matcher<const vector<int>&> m = UnorderedPointwise(IsHalfOf(), rhs);
5569   const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
5642   const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
5647   const Matcher<tuple<double, int> > m2 = IsHalfOf();