RootCore Packages: /cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/Asg_GoogleTest/include/gmock/gmock-generated-matchers.h Source File

00001 // This file was GENERATED by command:
00002 //     pump.py gmock-generated-matchers.h.pump
00003 // DO NOT EDIT BY HAND!!!
00004 
00005 // Copyright 2008, Google Inc.
00006 // All rights reserved.
00007 //
00008 // Redistribution and use in source and binary forms, with or without
00009 // modification, are permitted provided that the following conditions are
00010 // met:
00011 //
00012 //     * Redistributions of source code must retain the above copyright
00013 // notice, this list of conditions and the following disclaimer.
00014 //     * Redistributions in binary form must reproduce the above
00015 // copyright notice, this list of conditions and the following disclaimer
00016 // in the documentation and/or other materials provided with the
00017 // distribution.
00018 //     * Neither the name of Google Inc. nor the names of its
00019 // contributors may be used to endorse or promote products derived from
00020 // this software without specific prior written permission.
00021 //
00022 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00023 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00024 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00025 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00026 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00027 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00028 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00029 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00030 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00031 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00032 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00033 
00034 // Google Mock - a framework for writing C++ mock classes.
00035 //
00036 // This file implements some commonly used variadic matchers.
00037 
00038 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
00039 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
00040 
00041 #include <iterator>
00042 #include <sstream>
00043 #include <string>
00044 #include <vector>
00045 #include "gmock/gmock-matchers.h"
00046 
00047 namespace testing {
00048 namespace internal {
00049 
00050 // The type of the i-th (0-based) field of Tuple.
00051 #define GMOCK_FIELD_TYPE_(Tuple, i) \
00052     typename ::testing::tuple_element<i, Tuple>::type
00053 
00054 // TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
00055 // tuple of type Tuple.  It has two members:
00056 //
00057 //   type: a tuple type whose i-th field is the ki-th field of Tuple.
00058 //   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
00059 //
00060 // For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
00061 //
00062 //   type is tuple<int, bool>, and
00063 //   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
00064 
00065 template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
00066     int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
00067     int k9 = -1>
00068 class TupleFields;
00069 
00070 // This generic version is used when there are 10 selectors.
00071 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
00072     int k7, int k8, int k9>
00073 class TupleFields {
00074  public:
00075   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00076       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00077       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
00078       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
00079       GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
00080       GMOCK_FIELD_TYPE_(Tuple, k9)> type;
00081   static type GetSelectedFields(const Tuple& t) {
00082     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
00083         get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
00084   }
00085 };
00086 
00087 // The following specialization is used for 0 ~ 9 selectors.
00088 
00089 template <class Tuple>
00090 class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
00091  public:
00092   typedef ::testing::tuple<> type;
00093   static type GetSelectedFields(const Tuple& /* t */) {
00094     return type();
00095   }
00096 };
00097 
00098 template <class Tuple, int k0>
00099 class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
00100  public:
00101   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
00102   static type GetSelectedFields(const Tuple& t) {
00103     return type(get<k0>(t));
00104   }
00105 };
00106 
00107 template <class Tuple, int k0, int k1>
00108 class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
00109  public:
00110   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00111       GMOCK_FIELD_TYPE_(Tuple, k1)> type;
00112   static type GetSelectedFields(const Tuple& t) {
00113     return type(get<k0>(t), get<k1>(t));
00114   }
00115 };
00116 
00117 template <class Tuple, int k0, int k1, int k2>
00118 class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
00119  public:
00120   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00121       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
00122   static type GetSelectedFields(const Tuple& t) {
00123     return type(get<k0>(t), get<k1>(t), get<k2>(t));
00124   }
00125 };
00126 
00127 template <class Tuple, int k0, int k1, int k2, int k3>
00128 class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
00129  public:
00130   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00131       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00132       GMOCK_FIELD_TYPE_(Tuple, k3)> type;
00133   static type GetSelectedFields(const Tuple& t) {
00134     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
00135   }
00136 };
00137 
00138 template <class Tuple, int k0, int k1, int k2, int k3, int k4>
00139 class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
00140  public:
00141   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00142       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00143       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
00144   static type GetSelectedFields(const Tuple& t) {
00145     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
00146   }
00147 };
00148 
00149 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
00150 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
00151  public:
00152   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00153       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00154       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
00155       GMOCK_FIELD_TYPE_(Tuple, k5)> type;
00156   static type GetSelectedFields(const Tuple& t) {
00157     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
00158         get<k5>(t));
00159   }
00160 };
00161 
00162 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
00163 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
00164  public:
00165   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00166       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00167       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
00168       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
00169   static type GetSelectedFields(const Tuple& t) {
00170     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
00171         get<k5>(t), get<k6>(t));
00172   }
00173 };
00174 
00175 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
00176     int k7>
00177 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
00178  public:
00179   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00180       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00181       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
00182       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
00183       GMOCK_FIELD_TYPE_(Tuple, k7)> type;
00184   static type GetSelectedFields(const Tuple& t) {
00185     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
00186         get<k5>(t), get<k6>(t), get<k7>(t));
00187   }
00188 };
00189 
00190 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
00191     int k7, int k8>
00192 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
00193  public:
00194   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
00195       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
00196       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
00197       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
00198       GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
00199   static type GetSelectedFields(const Tuple& t) {
00200     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
00201         get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
00202   }
00203 };
00204 
00205 #undef GMOCK_FIELD_TYPE_
00206 
00207 // Implements the Args() matcher.
00208 template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
00209     int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
00210     int k9 = -1>
00211 class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
00212  public:
00213   // ArgsTuple may have top-level const or reference modifiers.
00214   typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
00215   typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
00216       k6, k7, k8, k9>::type SelectedArgs;
00217   typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
00218 
00219   template <typename InnerMatcher>
00220   explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
00221       : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
00222 
00223   virtual bool MatchAndExplain(ArgsTuple args,
00224                                MatchResultListener* listener) const {
00225     const SelectedArgs& selected_args = GetSelectedArgs(args);
00226     if (!listener->IsInterested())
00227       return inner_matcher_.Matches(selected_args);
00228 
00229     PrintIndices(listener->stream());
00230     *listener << "are " << PrintToString(selected_args);
00231 
00232     StringMatchResultListener inner_listener;
00233     const bool match = inner_matcher_.MatchAndExplain(selected_args,
00234                                                       &inner_listener);
00235     PrintIfNotEmpty(inner_listener.str(), listener->stream());
00236     return match;
00237   }
00238 
00239   virtual void DescribeTo(::std::ostream* os) const {
00240     *os << "are a tuple ";
00241     PrintIndices(os);
00242     inner_matcher_.DescribeTo(os);
00243   }
00244 
00245   virtual void DescribeNegationTo(::std::ostream* os) const {
00246     *os << "are a tuple ";
00247     PrintIndices(os);
00248     inner_matcher_.DescribeNegationTo(os);
00249   }
00250 
00251  private:
00252   static SelectedArgs GetSelectedArgs(ArgsTuple args) {
00253     return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
00254         k9>::GetSelectedFields(args);
00255   }
00256 
00257   // Prints the indices of the selected fields.
00258   static void PrintIndices(::std::ostream* os) {
00259     *os << "whose fields (";
00260     const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
00261     for (int i = 0; i < 10; i++) {
00262       if (indices[i] < 0)
00263         break;
00264 
00265       if (i >= 1)
00266         *os << ", ";
00267 
00268       *os << "#" << indices[i];
00269     }
00270     *os << ") ";
00271   }
00272 
00273   const MonomorphicInnerMatcher inner_matcher_;
00274 
00275   GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
00276 };
00277 
00278 template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
00279     int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
00280     int k8 = -1, int k9 = -1>
00281 class ArgsMatcher {
00282  public:
00283   explicit ArgsMatcher(const InnerMatcher& inner_matcher)
00284       : inner_matcher_(inner_matcher) {}
00285 
00286   template <typename ArgsTuple>
00287   operator Matcher<ArgsTuple>() const {
00288     return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
00289         k6, k7, k8, k9>(inner_matcher_));
00290   }
00291 
00292  private:
00293   const InnerMatcher inner_matcher_;
00294 
00295   GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
00296 };
00297 
00298 // A set of metafunctions for computing the result type of AllOf.
00299 // AllOf(m1, ..., mN) returns
00300 // AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
00301 
00302 // Although AllOf isn't defined for one argument, AllOfResult1 is defined
00303 // to simplify the implementation.
00304 template <typename M1>
00305 struct AllOfResult1 {
00306   typedef M1 type;
00307 };
00308 
00309 template <typename M1, typename M2>
00310 struct AllOfResult2 {
00311   typedef BothOfMatcher<
00312       typename AllOfResult1<M1>::type,
00313       typename AllOfResult1<M2>::type
00314   > type;
00315 };
00316 
00317 template <typename M1, typename M2, typename M3>
00318 struct AllOfResult3 {
00319   typedef BothOfMatcher<
00320       typename AllOfResult1<M1>::type,
00321       typename AllOfResult2<M2, M3>::type
00322   > type;
00323 };
00324 
00325 template <typename M1, typename M2, typename M3, typename M4>
00326 struct AllOfResult4 {
00327   typedef BothOfMatcher<
00328       typename AllOfResult2<M1, M2>::type,
00329       typename AllOfResult2<M3, M4>::type
00330   > type;
00331 };
00332 
00333 template <typename M1, typename M2, typename M3, typename M4, typename M5>
00334 struct AllOfResult5 {
00335   typedef BothOfMatcher<
00336       typename AllOfResult2<M1, M2>::type,
00337       typename AllOfResult3<M3, M4, M5>::type
00338   > type;
00339 };
00340 
00341 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00342     typename M6>
00343 struct AllOfResult6 {
00344   typedef BothOfMatcher<
00345       typename AllOfResult3<M1, M2, M3>::type,
00346       typename AllOfResult3<M4, M5, M6>::type
00347   > type;
00348 };
00349 
00350 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00351     typename M6, typename M7>
00352 struct AllOfResult7 {
00353   typedef BothOfMatcher<
00354       typename AllOfResult3<M1, M2, M3>::type,
00355       typename AllOfResult4<M4, M5, M6, M7>::type
00356   > type;
00357 };
00358 
00359 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00360     typename M6, typename M7, typename M8>
00361 struct AllOfResult8 {
00362   typedef BothOfMatcher<
00363       typename AllOfResult4<M1, M2, M3, M4>::type,
00364       typename AllOfResult4<M5, M6, M7, M8>::type
00365   > type;
00366 };
00367 
00368 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00369     typename M6, typename M7, typename M8, typename M9>
00370 struct AllOfResult9 {
00371   typedef BothOfMatcher<
00372       typename AllOfResult4<M1, M2, M3, M4>::type,
00373       typename AllOfResult5<M5, M6, M7, M8, M9>::type
00374   > type;
00375 };
00376 
00377 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00378     typename M6, typename M7, typename M8, typename M9, typename M10>
00379 struct AllOfResult10 {
00380   typedef BothOfMatcher<
00381       typename AllOfResult5<M1, M2, M3, M4, M5>::type,
00382       typename AllOfResult5<M6, M7, M8, M9, M10>::type
00383   > type;
00384 };
00385 
00386 // A set of metafunctions for computing the result type of AnyOf.
00387 // AnyOf(m1, ..., mN) returns
00388 // AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
00389 
00390 // Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
00391 // to simplify the implementation.
00392 template <typename M1>
00393 struct AnyOfResult1 {
00394   typedef M1 type;
00395 };
00396 
00397 template <typename M1, typename M2>
00398 struct AnyOfResult2 {
00399   typedef EitherOfMatcher<
00400       typename AnyOfResult1<M1>::type,
00401       typename AnyOfResult1<M2>::type
00402   > type;
00403 };
00404 
00405 template <typename M1, typename M2, typename M3>
00406 struct AnyOfResult3 {
00407   typedef EitherOfMatcher<
00408       typename AnyOfResult1<M1>::type,
00409       typename AnyOfResult2<M2, M3>::type
00410   > type;
00411 };
00412 
00413 template <typename M1, typename M2, typename M3, typename M4>
00414 struct AnyOfResult4 {
00415   typedef EitherOfMatcher<
00416       typename AnyOfResult2<M1, M2>::type,
00417       typename AnyOfResult2<M3, M4>::type
00418   > type;
00419 };
00420 
00421 template <typename M1, typename M2, typename M3, typename M4, typename M5>
00422 struct AnyOfResult5 {
00423   typedef EitherOfMatcher<
00424       typename AnyOfResult2<M1, M2>::type,
00425       typename AnyOfResult3<M3, M4, M5>::type
00426   > type;
00427 };
00428 
00429 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00430     typename M6>
00431 struct AnyOfResult6 {
00432   typedef EitherOfMatcher<
00433       typename AnyOfResult3<M1, M2, M3>::type,
00434       typename AnyOfResult3<M4, M5, M6>::type
00435   > type;
00436 };
00437 
00438 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00439     typename M6, typename M7>
00440 struct AnyOfResult7 {
00441   typedef EitherOfMatcher<
00442       typename AnyOfResult3<M1, M2, M3>::type,
00443       typename AnyOfResult4<M4, M5, M6, M7>::type
00444   > type;
00445 };
00446 
00447 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00448     typename M6, typename M7, typename M8>
00449 struct AnyOfResult8 {
00450   typedef EitherOfMatcher<
00451       typename AnyOfResult4<M1, M2, M3, M4>::type,
00452       typename AnyOfResult4<M5, M6, M7, M8>::type
00453   > type;
00454 };
00455 
00456 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00457     typename M6, typename M7, typename M8, typename M9>
00458 struct AnyOfResult9 {
00459   typedef EitherOfMatcher<
00460       typename AnyOfResult4<M1, M2, M3, M4>::type,
00461       typename AnyOfResult5<M5, M6, M7, M8, M9>::type
00462   > type;
00463 };
00464 
00465 template <typename M1, typename M2, typename M3, typename M4, typename M5,
00466     typename M6, typename M7, typename M8, typename M9, typename M10>
00467 struct AnyOfResult10 {
00468   typedef EitherOfMatcher<
00469       typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
00470       typename AnyOfResult5<M6, M7, M8, M9, M10>::type
00471   > type;
00472 };
00473 
00474 }  // namespace internal
00475 
00476 // Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
00477 // fields of it matches a_matcher.  C++ doesn't support default
00478 // arguments for function templates, so we have to overload it.
00479 template <typename InnerMatcher>
00480 inline internal::ArgsMatcher<InnerMatcher>
00481 Args(const InnerMatcher& matcher) {
00482   return internal::ArgsMatcher<InnerMatcher>(matcher);
00483 }
00484 
00485 template <int k1, typename InnerMatcher>
00486 inline internal::ArgsMatcher<InnerMatcher, k1>
00487 Args(const InnerMatcher& matcher) {
00488   return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
00489 }
00490 
00491 template <int k1, int k2, typename InnerMatcher>
00492 inline internal::ArgsMatcher<InnerMatcher, k1, k2>
00493 Args(const InnerMatcher& matcher) {
00494   return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
00495 }
00496 
00497 template <int k1, int k2, int k3, typename InnerMatcher>
00498 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
00499 Args(const InnerMatcher& matcher) {
00500   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
00501 }
00502 
00503 template <int k1, int k2, int k3, int k4, typename InnerMatcher>
00504 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
00505 Args(const InnerMatcher& matcher) {
00506   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
00507 }
00508 
00509 template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
00510 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
00511 Args(const InnerMatcher& matcher) {
00512   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
00513 }
00514 
00515 template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
00516 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
00517 Args(const InnerMatcher& matcher) {
00518   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
00519 }
00520 
00521 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
00522     typename InnerMatcher>
00523 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
00524 Args(const InnerMatcher& matcher) {
00525   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
00526       k7>(matcher);
00527 }
00528 
00529 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
00530     typename InnerMatcher>
00531 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
00532 Args(const InnerMatcher& matcher) {
00533   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
00534       k8>(matcher);
00535 }
00536 
00537 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
00538     int k9, typename InnerMatcher>
00539 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
00540 Args(const InnerMatcher& matcher) {
00541   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
00542       k9>(matcher);
00543 }
00544 
00545 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
00546     int k9, int k10, typename InnerMatcher>
00547 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
00548     k10>
00549 Args(const InnerMatcher& matcher) {
00550   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
00551       k9, k10>(matcher);
00552 }
00553 
00554 // ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
00555 // n elements, where the i-th element in the container must
00556 // match the i-th argument in the list.  Each argument of
00557 // ElementsAre() can be either a value or a matcher.  We support up to
00558 // 10 arguments.
00559 //
00560 // The use of DecayArray in the implementation allows ElementsAre()
00561 // to accept string literals, whose type is const char[N], but we
00562 // want to treat them as const char*.
00563 //
00564 // NOTE: Since ElementsAre() cares about the order of the elements, it
00565 // must not be used with containers whose elements's order is
00566 // undefined (e.g. hash_map).
00567 
00568 inline internal::ElementsAreMatcher<
00569     ::testing::tuple<> >
00570 ElementsAre() {
00571   typedef ::testing::tuple<> Args;
00572   return internal::ElementsAreMatcher<Args>(Args());
00573 }
00574 
00575 template <typename T1>
00576 inline internal::ElementsAreMatcher<
00577     ::testing::tuple<
00578         typename internal::DecayArray<T1>::type> >
00579 ElementsAre(const T1& e1) {
00580   typedef ::testing::tuple<
00581       typename internal::DecayArray<T1>::type> Args;
00582   return internal::ElementsAreMatcher<Args>(Args(e1));
00583 }
00584 
00585 template <typename T1, typename T2>
00586 inline internal::ElementsAreMatcher<
00587     ::testing::tuple<
00588         typename internal::DecayArray<T1>::type,
00589         typename internal::DecayArray<T2>::type> >
00590 ElementsAre(const T1& e1, const T2& e2) {
00591   typedef ::testing::tuple<
00592       typename internal::DecayArray<T1>::type,
00593       typename internal::DecayArray<T2>::type> Args;
00594   return internal::ElementsAreMatcher<Args>(Args(e1, e2));
00595 }
00596 
00597 template <typename T1, typename T2, typename T3>
00598 inline internal::ElementsAreMatcher<
00599     ::testing::tuple<
00600         typename internal::DecayArray<T1>::type,
00601         typename internal::DecayArray<T2>::type,
00602         typename internal::DecayArray<T3>::type> >
00603 ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
00604   typedef ::testing::tuple<
00605       typename internal::DecayArray<T1>::type,
00606       typename internal::DecayArray<T2>::type,
00607       typename internal::DecayArray<T3>::type> Args;
00608   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
00609 }
00610 
00611 template <typename T1, typename T2, typename T3, typename T4>
00612 inline internal::ElementsAreMatcher<
00613     ::testing::tuple<
00614         typename internal::DecayArray<T1>::type,
00615         typename internal::DecayArray<T2>::type,
00616         typename internal::DecayArray<T3>::type,
00617         typename internal::DecayArray<T4>::type> >
00618 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
00619   typedef ::testing::tuple<
00620       typename internal::DecayArray<T1>::type,
00621       typename internal::DecayArray<T2>::type,
00622       typename internal::DecayArray<T3>::type,
00623       typename internal::DecayArray<T4>::type> Args;
00624   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
00625 }
00626 
00627 template <typename T1, typename T2, typename T3, typename T4, typename T5>
00628 inline internal::ElementsAreMatcher<
00629     ::testing::tuple<
00630         typename internal::DecayArray<T1>::type,
00631         typename internal::DecayArray<T2>::type,
00632         typename internal::DecayArray<T3>::type,
00633         typename internal::DecayArray<T4>::type,
00634         typename internal::DecayArray<T5>::type> >
00635 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00636     const T5& e5) {
00637   typedef ::testing::tuple<
00638       typename internal::DecayArray<T1>::type,
00639       typename internal::DecayArray<T2>::type,
00640       typename internal::DecayArray<T3>::type,
00641       typename internal::DecayArray<T4>::type,
00642       typename internal::DecayArray<T5>::type> Args;
00643   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
00644 }
00645 
00646 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00647     typename T6>
00648 inline internal::ElementsAreMatcher<
00649     ::testing::tuple<
00650         typename internal::DecayArray<T1>::type,
00651         typename internal::DecayArray<T2>::type,
00652         typename internal::DecayArray<T3>::type,
00653         typename internal::DecayArray<T4>::type,
00654         typename internal::DecayArray<T5>::type,
00655         typename internal::DecayArray<T6>::type> >
00656 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00657     const T5& e5, const T6& e6) {
00658   typedef ::testing::tuple<
00659       typename internal::DecayArray<T1>::type,
00660       typename internal::DecayArray<T2>::type,
00661       typename internal::DecayArray<T3>::type,
00662       typename internal::DecayArray<T4>::type,
00663       typename internal::DecayArray<T5>::type,
00664       typename internal::DecayArray<T6>::type> Args;
00665   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
00666 }
00667 
00668 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00669     typename T6, typename T7>
00670 inline internal::ElementsAreMatcher<
00671     ::testing::tuple<
00672         typename internal::DecayArray<T1>::type,
00673         typename internal::DecayArray<T2>::type,
00674         typename internal::DecayArray<T3>::type,
00675         typename internal::DecayArray<T4>::type,
00676         typename internal::DecayArray<T5>::type,
00677         typename internal::DecayArray<T6>::type,
00678         typename internal::DecayArray<T7>::type> >
00679 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00680     const T5& e5, const T6& e6, const T7& e7) {
00681   typedef ::testing::tuple<
00682       typename internal::DecayArray<T1>::type,
00683       typename internal::DecayArray<T2>::type,
00684       typename internal::DecayArray<T3>::type,
00685       typename internal::DecayArray<T4>::type,
00686       typename internal::DecayArray<T5>::type,
00687       typename internal::DecayArray<T6>::type,
00688       typename internal::DecayArray<T7>::type> Args;
00689   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
00690 }
00691 
00692 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00693     typename T6, typename T7, typename T8>
00694 inline internal::ElementsAreMatcher<
00695     ::testing::tuple<
00696         typename internal::DecayArray<T1>::type,
00697         typename internal::DecayArray<T2>::type,
00698         typename internal::DecayArray<T3>::type,
00699         typename internal::DecayArray<T4>::type,
00700         typename internal::DecayArray<T5>::type,
00701         typename internal::DecayArray<T6>::type,
00702         typename internal::DecayArray<T7>::type,
00703         typename internal::DecayArray<T8>::type> >
00704 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00705     const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
00706   typedef ::testing::tuple<
00707       typename internal::DecayArray<T1>::type,
00708       typename internal::DecayArray<T2>::type,
00709       typename internal::DecayArray<T3>::type,
00710       typename internal::DecayArray<T4>::type,
00711       typename internal::DecayArray<T5>::type,
00712       typename internal::DecayArray<T6>::type,
00713       typename internal::DecayArray<T7>::type,
00714       typename internal::DecayArray<T8>::type> Args;
00715   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
00716       e8));
00717 }
00718 
00719 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00720     typename T6, typename T7, typename T8, typename T9>
00721 inline internal::ElementsAreMatcher<
00722     ::testing::tuple<
00723         typename internal::DecayArray<T1>::type,
00724         typename internal::DecayArray<T2>::type,
00725         typename internal::DecayArray<T3>::type,
00726         typename internal::DecayArray<T4>::type,
00727         typename internal::DecayArray<T5>::type,
00728         typename internal::DecayArray<T6>::type,
00729         typename internal::DecayArray<T7>::type,
00730         typename internal::DecayArray<T8>::type,
00731         typename internal::DecayArray<T9>::type> >
00732 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00733     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
00734   typedef ::testing::tuple<
00735       typename internal::DecayArray<T1>::type,
00736       typename internal::DecayArray<T2>::type,
00737       typename internal::DecayArray<T3>::type,
00738       typename internal::DecayArray<T4>::type,
00739       typename internal::DecayArray<T5>::type,
00740       typename internal::DecayArray<T6>::type,
00741       typename internal::DecayArray<T7>::type,
00742       typename internal::DecayArray<T8>::type,
00743       typename internal::DecayArray<T9>::type> Args;
00744   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
00745       e8, e9));
00746 }
00747 
00748 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00749     typename T6, typename T7, typename T8, typename T9, typename T10>
00750 inline internal::ElementsAreMatcher<
00751     ::testing::tuple<
00752         typename internal::DecayArray<T1>::type,
00753         typename internal::DecayArray<T2>::type,
00754         typename internal::DecayArray<T3>::type,
00755         typename internal::DecayArray<T4>::type,
00756         typename internal::DecayArray<T5>::type,
00757         typename internal::DecayArray<T6>::type,
00758         typename internal::DecayArray<T7>::type,
00759         typename internal::DecayArray<T8>::type,
00760         typename internal::DecayArray<T9>::type,
00761         typename internal::DecayArray<T10>::type> >
00762 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00763     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
00764     const T10& e10) {
00765   typedef ::testing::tuple<
00766       typename internal::DecayArray<T1>::type,
00767       typename internal::DecayArray<T2>::type,
00768       typename internal::DecayArray<T3>::type,
00769       typename internal::DecayArray<T4>::type,
00770       typename internal::DecayArray<T5>::type,
00771       typename internal::DecayArray<T6>::type,
00772       typename internal::DecayArray<T7>::type,
00773       typename internal::DecayArray<T8>::type,
00774       typename internal::DecayArray<T9>::type,
00775       typename internal::DecayArray<T10>::type> Args;
00776   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
00777       e8, e9, e10));
00778 }
00779 
00780 // UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
00781 // that matches n elements in any order.  We support up to n=10 arguments.
00782 
00783 inline internal::UnorderedElementsAreMatcher<
00784     ::testing::tuple<> >
00785 UnorderedElementsAre() {
00786   typedef ::testing::tuple<> Args;
00787   return internal::UnorderedElementsAreMatcher<Args>(Args());
00788 }
00789 
00790 template <typename T1>
00791 inline internal::UnorderedElementsAreMatcher<
00792     ::testing::tuple<
00793         typename internal::DecayArray<T1>::type> >
00794 UnorderedElementsAre(const T1& e1) {
00795   typedef ::testing::tuple<
00796       typename internal::DecayArray<T1>::type> Args;
00797   return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
00798 }
00799 
00800 template <typename T1, typename T2>
00801 inline internal::UnorderedElementsAreMatcher<
00802     ::testing::tuple<
00803         typename internal::DecayArray<T1>::type,
00804         typename internal::DecayArray<T2>::type> >
00805 UnorderedElementsAre(const T1& e1, const T2& e2) {
00806   typedef ::testing::tuple<
00807       typename internal::DecayArray<T1>::type,
00808       typename internal::DecayArray<T2>::type> Args;
00809   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
00810 }
00811 
00812 template <typename T1, typename T2, typename T3>
00813 inline internal::UnorderedElementsAreMatcher<
00814     ::testing::tuple<
00815         typename internal::DecayArray<T1>::type,
00816         typename internal::DecayArray<T2>::type,
00817         typename internal::DecayArray<T3>::type> >
00818 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
00819   typedef ::testing::tuple<
00820       typename internal::DecayArray<T1>::type,
00821       typename internal::DecayArray<T2>::type,
00822       typename internal::DecayArray<T3>::type> Args;
00823   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
00824 }
00825 
00826 template <typename T1, typename T2, typename T3, typename T4>
00827 inline internal::UnorderedElementsAreMatcher<
00828     ::testing::tuple<
00829         typename internal::DecayArray<T1>::type,
00830         typename internal::DecayArray<T2>::type,
00831         typename internal::DecayArray<T3>::type,
00832         typename internal::DecayArray<T4>::type> >
00833 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
00834   typedef ::testing::tuple<
00835       typename internal::DecayArray<T1>::type,
00836       typename internal::DecayArray<T2>::type,
00837       typename internal::DecayArray<T3>::type,
00838       typename internal::DecayArray<T4>::type> Args;
00839   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
00840 }
00841 
00842 template <typename T1, typename T2, typename T3, typename T4, typename T5>
00843 inline internal::UnorderedElementsAreMatcher<
00844     ::testing::tuple<
00845         typename internal::DecayArray<T1>::type,
00846         typename internal::DecayArray<T2>::type,
00847         typename internal::DecayArray<T3>::type,
00848         typename internal::DecayArray<T4>::type,
00849         typename internal::DecayArray<T5>::type> >
00850 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00851     const T5& e5) {
00852   typedef ::testing::tuple<
00853       typename internal::DecayArray<T1>::type,
00854       typename internal::DecayArray<T2>::type,
00855       typename internal::DecayArray<T3>::type,
00856       typename internal::DecayArray<T4>::type,
00857       typename internal::DecayArray<T5>::type> Args;
00858   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
00859 }
00860 
00861 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00862     typename T6>
00863 inline internal::UnorderedElementsAreMatcher<
00864     ::testing::tuple<
00865         typename internal::DecayArray<T1>::type,
00866         typename internal::DecayArray<T2>::type,
00867         typename internal::DecayArray<T3>::type,
00868         typename internal::DecayArray<T4>::type,
00869         typename internal::DecayArray<T5>::type,
00870         typename internal::DecayArray<T6>::type> >
00871 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00872     const T5& e5, const T6& e6) {
00873   typedef ::testing::tuple<
00874       typename internal::DecayArray<T1>::type,
00875       typename internal::DecayArray<T2>::type,
00876       typename internal::DecayArray<T3>::type,
00877       typename internal::DecayArray<T4>::type,
00878       typename internal::DecayArray<T5>::type,
00879       typename internal::DecayArray<T6>::type> Args;
00880   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
00881       e6));
00882 }
00883 
00884 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00885     typename T6, typename T7>
00886 inline internal::UnorderedElementsAreMatcher<
00887     ::testing::tuple<
00888         typename internal::DecayArray<T1>::type,
00889         typename internal::DecayArray<T2>::type,
00890         typename internal::DecayArray<T3>::type,
00891         typename internal::DecayArray<T4>::type,
00892         typename internal::DecayArray<T5>::type,
00893         typename internal::DecayArray<T6>::type,
00894         typename internal::DecayArray<T7>::type> >
00895 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00896     const T5& e5, const T6& e6, const T7& e7) {
00897   typedef ::testing::tuple<
00898       typename internal::DecayArray<T1>::type,
00899       typename internal::DecayArray<T2>::type,
00900       typename internal::DecayArray<T3>::type,
00901       typename internal::DecayArray<T4>::type,
00902       typename internal::DecayArray<T5>::type,
00903       typename internal::DecayArray<T6>::type,
00904       typename internal::DecayArray<T7>::type> Args;
00905   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
00906       e6, e7));
00907 }
00908 
00909 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00910     typename T6, typename T7, typename T8>
00911 inline internal::UnorderedElementsAreMatcher<
00912     ::testing::tuple<
00913         typename internal::DecayArray<T1>::type,
00914         typename internal::DecayArray<T2>::type,
00915         typename internal::DecayArray<T3>::type,
00916         typename internal::DecayArray<T4>::type,
00917         typename internal::DecayArray<T5>::type,
00918         typename internal::DecayArray<T6>::type,
00919         typename internal::DecayArray<T7>::type,
00920         typename internal::DecayArray<T8>::type> >
00921 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00922     const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
00923   typedef ::testing::tuple<
00924       typename internal::DecayArray<T1>::type,
00925       typename internal::DecayArray<T2>::type,
00926       typename internal::DecayArray<T3>::type,
00927       typename internal::DecayArray<T4>::type,
00928       typename internal::DecayArray<T5>::type,
00929       typename internal::DecayArray<T6>::type,
00930       typename internal::DecayArray<T7>::type,
00931       typename internal::DecayArray<T8>::type> Args;
00932   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
00933       e6, e7, e8));
00934 }
00935 
00936 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00937     typename T6, typename T7, typename T8, typename T9>
00938 inline internal::UnorderedElementsAreMatcher<
00939     ::testing::tuple<
00940         typename internal::DecayArray<T1>::type,
00941         typename internal::DecayArray<T2>::type,
00942         typename internal::DecayArray<T3>::type,
00943         typename internal::DecayArray<T4>::type,
00944         typename internal::DecayArray<T5>::type,
00945         typename internal::DecayArray<T6>::type,
00946         typename internal::DecayArray<T7>::type,
00947         typename internal::DecayArray<T8>::type,
00948         typename internal::DecayArray<T9>::type> >
00949 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00950     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
00951   typedef ::testing::tuple<
00952       typename internal::DecayArray<T1>::type,
00953       typename internal::DecayArray<T2>::type,
00954       typename internal::DecayArray<T3>::type,
00955       typename internal::DecayArray<T4>::type,
00956       typename internal::DecayArray<T5>::type,
00957       typename internal::DecayArray<T6>::type,
00958       typename internal::DecayArray<T7>::type,
00959       typename internal::DecayArray<T8>::type,
00960       typename internal::DecayArray<T9>::type> Args;
00961   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
00962       e6, e7, e8, e9));
00963 }
00964 
00965 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00966     typename T6, typename T7, typename T8, typename T9, typename T10>
00967 inline internal::UnorderedElementsAreMatcher<
00968     ::testing::tuple<
00969         typename internal::DecayArray<T1>::type,
00970         typename internal::DecayArray<T2>::type,
00971         typename internal::DecayArray<T3>::type,
00972         typename internal::DecayArray<T4>::type,
00973         typename internal::DecayArray<T5>::type,
00974         typename internal::DecayArray<T6>::type,
00975         typename internal::DecayArray<T7>::type,
00976         typename internal::DecayArray<T8>::type,
00977         typename internal::DecayArray<T9>::type,
00978         typename internal::DecayArray<T10>::type> >
00979 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
00980     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
00981     const T10& e10) {
00982   typedef ::testing::tuple<
00983       typename internal::DecayArray<T1>::type,
00984       typename internal::DecayArray<T2>::type,
00985       typename internal::DecayArray<T3>::type,
00986       typename internal::DecayArray<T4>::type,
00987       typename internal::DecayArray<T5>::type,
00988       typename internal::DecayArray<T6>::type,
00989       typename internal::DecayArray<T7>::type,
00990       typename internal::DecayArray<T8>::type,
00991       typename internal::DecayArray<T9>::type,
00992       typename internal::DecayArray<T10>::type> Args;
00993   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
00994       e6, e7, e8, e9, e10));
00995 }
00996 
00997 // AllOf(m1, m2, ..., mk) matches any value that matches all of the given
00998 // sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
00999 
01000 template <typename M1, typename M2>
01001 inline typename internal::AllOfResult2<M1, M2>::type
01002 AllOf(M1 m1, M2 m2) {
01003   return typename internal::AllOfResult2<M1, M2>::type(
01004       m1,
01005       m2);
01006 }
01007 
01008 template <typename M1, typename M2, typename M3>
01009 inline typename internal::AllOfResult3<M1, M2, M3>::type
01010 AllOf(M1 m1, M2 m2, M3 m3) {
01011   return typename internal::AllOfResult3<M1, M2, M3>::type(
01012       m1,
01013       ::testing::AllOf(m2, m3));
01014 }
01015 
01016 template <typename M1, typename M2, typename M3, typename M4>
01017 inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
01018 AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
01019   return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
01020       ::testing::AllOf(m1, m2),
01021       ::testing::AllOf(m3, m4));
01022 }
01023 
01024 template <typename M1, typename M2, typename M3, typename M4, typename M5>
01025 inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
01026 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
01027   return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
01028       ::testing::AllOf(m1, m2),
01029       ::testing::AllOf(m3, m4, m5));
01030 }
01031 
01032 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01033     typename M6>
01034 inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
01035 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
01036   return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
01037       ::testing::AllOf(m1, m2, m3),
01038       ::testing::AllOf(m4, m5, m6));
01039 }
01040 
01041 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01042     typename M6, typename M7>
01043 inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
01044 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
01045   return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
01046       ::testing::AllOf(m1, m2, m3),
01047       ::testing::AllOf(m4, m5, m6, m7));
01048 }
01049 
01050 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01051     typename M6, typename M7, typename M8>
01052 inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
01053 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
01054   return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
01055       ::testing::AllOf(m1, m2, m3, m4),
01056       ::testing::AllOf(m5, m6, m7, m8));
01057 }
01058 
01059 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01060     typename M6, typename M7, typename M8, typename M9>
01061 inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
01062 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
01063   return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
01064       M9>::type(
01065       ::testing::AllOf(m1, m2, m3, m4),
01066       ::testing::AllOf(m5, m6, m7, m8, m9));
01067 }
01068 
01069 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01070     typename M6, typename M7, typename M8, typename M9, typename M10>
01071 inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
01072     M10>::type
01073 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
01074   return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
01075       M10>::type(
01076       ::testing::AllOf(m1, m2, m3, m4, m5),
01077       ::testing::AllOf(m6, m7, m8, m9, m10));
01078 }
01079 
01080 // AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
01081 // sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
01082 
01083 template <typename M1, typename M2>
01084 inline typename internal::AnyOfResult2<M1, M2>::type
01085 AnyOf(M1 m1, M2 m2) {
01086   return typename internal::AnyOfResult2<M1, M2>::type(
01087       m1,
01088       m2);
01089 }
01090 
01091 template <typename M1, typename M2, typename M3>
01092 inline typename internal::AnyOfResult3<M1, M2, M3>::type
01093 AnyOf(M1 m1, M2 m2, M3 m3) {
01094   return typename internal::AnyOfResult3<M1, M2, M3>::type(
01095       m1,
01096       ::testing::AnyOf(m2, m3));
01097 }
01098 
01099 template <typename M1, typename M2, typename M3, typename M4>
01100 inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
01101 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
01102   return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
01103       ::testing::AnyOf(m1, m2),
01104       ::testing::AnyOf(m3, m4));
01105 }
01106 
01107 template <typename M1, typename M2, typename M3, typename M4, typename M5>
01108 inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
01109 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
01110   return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
01111       ::testing::AnyOf(m1, m2),
01112       ::testing::AnyOf(m3, m4, m5));
01113 }
01114 
01115 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01116     typename M6>
01117 inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
01118 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
01119   return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
01120       ::testing::AnyOf(m1, m2, m3),
01121       ::testing::AnyOf(m4, m5, m6));
01122 }
01123 
01124 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01125     typename M6, typename M7>
01126 inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
01127 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
01128   return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
01129       ::testing::AnyOf(m1, m2, m3),
01130       ::testing::AnyOf(m4, m5, m6, m7));
01131 }
01132 
01133 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01134     typename M6, typename M7, typename M8>
01135 inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
01136 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
01137   return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
01138       ::testing::AnyOf(m1, m2, m3, m4),
01139       ::testing::AnyOf(m5, m6, m7, m8));
01140 }
01141 
01142 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01143     typename M6, typename M7, typename M8, typename M9>
01144 inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
01145 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
01146   return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
01147       M9>::type(
01148       ::testing::AnyOf(m1, m2, m3, m4),
01149       ::testing::AnyOf(m5, m6, m7, m8, m9));
01150 }
01151 
01152 template <typename M1, typename M2, typename M3, typename M4, typename M5,
01153     typename M6, typename M7, typename M8, typename M9, typename M10>
01154 inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
01155     M10>::type
01156 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
01157   return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
01158       M10>::type(
01159       ::testing::AnyOf(m1, m2, m3, m4, m5),
01160       ::testing::AnyOf(m6, m7, m8, m9, m10));
01161 }
01162 
01163 }  // namespace testing
01164 
01165 
01166 // The MATCHER* family of macros can be used in a namespace scope to
01167 // define custom matchers easily.
01168 //
01169 // Basic Usage
01170 // ===========
01171 //
01172 // The syntax
01173 //
01174 //   MATCHER(name, description_string) { statements; }
01175 //
01176 // defines a matcher with the given name that executes the statements,
01177 // which must return a bool to indicate if the match succeeds.  Inside
01178 // the statements, you can refer to the value being matched by 'arg',
01179 // and refer to its type by 'arg_type'.
01180 //
01181 // The description string documents what the matcher does, and is used
01182 // to generate the failure message when the match fails.  Since a
01183 // MATCHER() is usually defined in a header file shared by multiple
01184 // C++ source files, we require the description to be a C-string
01185 // literal to avoid possible side effects.  It can be empty, in which
01186 // case we'll use the sequence of words in the matcher name as the
01187 // description.
01188 //
01189 // For example:
01190 //
01191 //   MATCHER(IsEven, "") { return (arg % 2) == 0; }
01192 //
01193 // allows you to write
01194 //
01195 //   // Expects mock_foo.Bar(n) to be called where n is even.
01196 //   EXPECT_CALL(mock_foo, Bar(IsEven()));
01197 //
01198 // or,
01199 //
01200 //   // Verifies that the value of some_expression is even.
01201 //   EXPECT_THAT(some_expression, IsEven());
01202 //
01203 // If the above assertion fails, it will print something like:
01204 //
01205 //   Value of: some_expression
01206 //   Expected: is even
01207 //     Actual: 7
01208 //
01209 // where the description "is even" is automatically calculated from the
01210 // matcher name IsEven.
01211 //
01212 // Argument Type
01213 // =============
01214 //
01215 // Note that the type of the value being matched (arg_type) is
01216 // determined by the context in which you use the matcher and is
01217 // supplied to you by the compiler, so you don't need to worry about
01218 // declaring it (nor can you).  This allows the matcher to be
01219 // polymorphic.  For example, IsEven() can be used to match any type
01220 // where the value of "(arg % 2) == 0" can be implicitly converted to
01221 // a bool.  In the "Bar(IsEven())" example above, if method Bar()
01222 // takes an int, 'arg_type' will be int; if it takes an unsigned long,
01223 // 'arg_type' will be unsigned long; and so on.
01224 //
01225 // Parameterizing Matchers
01226 // =======================
01227 //
01228 // Sometimes you'll want to parameterize the matcher.  For that you
01229 // can use another macro:
01230 //
01231 //   MATCHER_P(name, param_name, description_string) { statements; }
01232 //
01233 // For example:
01234 //
01235 //   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
01236 //
01237 // will allow you to write:
01238 //
01239 //   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
01240 //
01241 // which may lead to this message (assuming n is 10):
01242 //
01243 //   Value of: Blah("a")
01244 //   Expected: has absolute value 10
01245 //     Actual: -9
01246 //
01247 // Note that both the matcher description and its parameter are
01248 // printed, making the message human-friendly.
01249 //
01250 // In the matcher definition body, you can write 'foo_type' to
01251 // reference the type of a parameter named 'foo'.  For example, in the
01252 // body of MATCHER_P(HasAbsoluteValue, value) above, you can write
01253 // 'value_type' to refer to the type of 'value'.
01254 //
01255 // We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
01256 // support multi-parameter matchers.
01257 //
01258 // Describing Parameterized Matchers
01259 // =================================
01260 //
01261 // The last argument to MATCHER*() is a string-typed expression.  The
01262 // expression can reference all of the matcher's parameters and a
01263 // special bool-typed variable named 'negation'.  When 'negation' is
01264 // false, the expression should evaluate to the matcher's description;
01265 // otherwise it should evaluate to the description of the negation of
01266 // the matcher.  For example,
01267 //
01268 //   using testing::PrintToString;
01269 //
01270 //   MATCHER_P2(InClosedRange, low, hi,
01271 //       string(negation ? "is not" : "is") + " in range [" +
01272 //       PrintToString(low) + ", " + PrintToString(hi) + "]") {
01273 //     return low <= arg && arg <= hi;
01274 //   }
01275 //   ...
01276 //   EXPECT_THAT(3, InClosedRange(4, 6));
01277 //   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
01278 //
01279 // would generate two failures that contain the text:
01280 //
01281 //   Expected: is in range [4, 6]
01282 //   ...
01283 //   Expected: is not in range [2, 4]
01284 //
01285 // If you specify "" as the description, the failure message will
01286 // contain the sequence of words in the matcher name followed by the
01287 // parameter values printed as a tuple.  For example,
01288 //
01289 //   MATCHER_P2(InClosedRange, low, hi, "") { ... }
01290 //   ...
01291 //   EXPECT_THAT(3, InClosedRange(4, 6));
01292 //   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
01293 //
01294 // would generate two failures that contain the text:
01295 //
01296 //   Expected: in closed range (4, 6)
01297 //   ...
01298 //   Expected: not (in closed range (2, 4))
01299 //
01300 // Types of Matcher Parameters
01301 // ===========================
01302 //
01303 // For the purpose of typing, you can view
01304 //
01305 //   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
01306 //
01307 // as shorthand for
01308 //
01309 //   template <typename p1_type, ..., typename pk_type>
01310 //   FooMatcherPk<p1_type, ..., pk_type>
01311 //   Foo(p1_type p1, ..., pk_type pk) { ... }
01312 //
01313 // When you write Foo(v1, ..., vk), the compiler infers the types of
01314 // the parameters v1, ..., and vk for you.  If you are not happy with
01315 // the result of the type inference, you can specify the types by
01316 // explicitly instantiating the template, as in Foo<long, bool>(5,
01317 // false).  As said earlier, you don't get to (or need to) specify
01318 // 'arg_type' as that's determined by the context in which the matcher
01319 // is used.  You can assign the result of expression Foo(p1, ..., pk)
01320 // to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
01321 // can be useful when composing matchers.
01322 //
01323 // While you can instantiate a matcher template with reference types,
01324 // passing the parameters by pointer usually makes your code more
01325 // readable.  If, however, you still want to pass a parameter by
01326 // reference, be aware that in the failure message generated by the
01327 // matcher you will see the value of the referenced object but not its
01328 // address.
01329 //
01330 // Explaining Match Results
01331 // ========================
01332 //
01333 // Sometimes the matcher description alone isn't enough to explain why
01334 // the match has failed or succeeded.  For example, when expecting a
01335 // long string, it can be very helpful to also print the diff between
01336 // the expected string and the actual one.  To achieve that, you can
01337 // optionally stream additional information to a special variable
01338 // named result_listener, whose type is a pointer to class
01339 // MatchResultListener:
01340 //
01341 //   MATCHER_P(EqualsLongString, str, "") {
01342 //     if (arg == str) return true;
01343 //
01344 //     *result_listener << "the difference: "
01346 //     return false;
01347 //   }
01348 //
01349 // Overloading Matchers
01350 // ====================
01351 //
01352 // You can overload matchers with different numbers of parameters:
01353 //
01354 //   MATCHER_P(Blah, a, description_string1) { ... }
01355 //   MATCHER_P2(Blah, a, b, description_string2) { ... }
01356 //
01357 // Caveats
01358 // =======
01359 //
01360 // When defining a new matcher, you should also consider implementing
01361 // MatcherInterface or using MakePolymorphicMatcher().  These
01362 // approaches require more work than the MATCHER* macros, but also
01363 // give you more control on the types of the value being matched and
01364 // the matcher parameters, which may leads to better compiler error
01365 // messages when the matcher is used wrong.  They also allow
01366 // overloading matchers based on parameter types (as opposed to just
01367 // based on the number of parameters).
01368 //
01369 // MATCHER*() can only be used in a namespace scope.  The reason is
01370 // that C++ doesn't yet allow function-local types to be used to
01371 // instantiate templates.  The up-coming C++0x standard will fix this.
01372 // Once that's done, we'll consider supporting using MATCHER*() inside
01373 // a function.
01374 //
01375 // More Information
01376 // ================
01377 //
01378 // To learn more about using these macros, please search for 'MATCHER'
01379 // on http://code.google.com/p/googlemock/wiki/CookBook.
01380 
01381 #define MATCHER(name, description)\
01382   class name##Matcher {\
01383    public:\
01384     template <typename arg_type>\
01385     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01386      public:\
01387       gmock_Impl()\
01388            {}\
01389       virtual bool MatchAndExplain(\
01390           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01391       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01392         *gmock_os << FormatDescription(false);\
01393       }\
01394       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01395         *gmock_os << FormatDescription(true);\
01396       }\
01397      private:\
01398       ::testing::internal::string FormatDescription(bool negation) const {\
01399         const ::testing::internal::string gmock_description = (description);\
01400         if (!gmock_description.empty())\
01401           return gmock_description;\
01402         return ::testing::internal::FormatMatcherDescription(\
01403             negation, #name, \
01404             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01405                 ::testing::tuple<>()));\
01406       }\
01407       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01408     };\
01409     template <typename arg_type>\
01410     operator ::testing::Matcher<arg_type>() const {\
01411       return ::testing::Matcher<arg_type>(\
01412           new gmock_Impl<arg_type>());\
01413     }\
01414     name##Matcher() {\
01415     }\
01416    private:\
01417     GTEST_DISALLOW_ASSIGN_(name##Matcher);\
01418   };\
01419   inline name##Matcher name() {\
01420     return name##Matcher();\
01421   }\
01422   template <typename arg_type>\
01423   bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
01424       arg_type arg, \
01425       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01426           const
01427 
01428 #define MATCHER_P(name, p0, description)\
01429   template <typename p0##_type>\
01430   class name##MatcherP {\
01431    public:\
01432     template <typename arg_type>\
01433     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01434      public:\
01435       explicit gmock_Impl(p0##_type gmock_p0)\
01436            : p0(gmock_p0) {}\
01437       virtual bool MatchAndExplain(\
01438           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01439       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01440         *gmock_os << FormatDescription(false);\
01441       }\
01442       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01443         *gmock_os << FormatDescription(true);\
01444       }\
01445       p0##_type p0;\
01446      private:\
01447       ::testing::internal::string FormatDescription(bool negation) const {\
01448         const ::testing::internal::string gmock_description = (description);\
01449         if (!gmock_description.empty())\
01450           return gmock_description;\
01451         return ::testing::internal::FormatMatcherDescription(\
01452             negation, #name, \
01453             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01454                 ::testing::tuple<p0##_type>(p0)));\
01455       }\
01456       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01457     };\
01458     template <typename arg_type>\
01459     operator ::testing::Matcher<arg_type>() const {\
01460       return ::testing::Matcher<arg_type>(\
01461           new gmock_Impl<arg_type>(p0));\
01462     }\
01463     explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
01464     }\
01465     p0##_type p0;\
01466    private:\
01467     GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
01468   };\
01469   template <typename p0##_type>\
01470   inline name##MatcherP<p0##_type> name(p0##_type p0) {\
01471     return name##MatcherP<p0##_type>(p0);\
01472   }\
01473   template <typename p0##_type>\
01474   template <typename arg_type>\
01475   bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01476       arg_type arg, \
01477       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01478           const
01479 
01480 #define MATCHER_P2(name, p0, p1, description)\
01481   template <typename p0##_type, typename p1##_type>\
01482   class name##MatcherP2 {\
01483    public:\
01484     template <typename arg_type>\
01485     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01486      public:\
01487       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
01488            : p0(gmock_p0), p1(gmock_p1) {}\
01489       virtual bool MatchAndExplain(\
01490           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01491       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01492         *gmock_os << FormatDescription(false);\
01493       }\
01494       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01495         *gmock_os << FormatDescription(true);\
01496       }\
01497       p0##_type p0;\
01498       p1##_type p1;\
01499      private:\
01500       ::testing::internal::string FormatDescription(bool negation) const {\
01501         const ::testing::internal::string gmock_description = (description);\
01502         if (!gmock_description.empty())\
01503           return gmock_description;\
01504         return ::testing::internal::FormatMatcherDescription(\
01505             negation, #name, \
01506             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01507                 ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
01508       }\
01509       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01510     };\
01511     template <typename arg_type>\
01512     operator ::testing::Matcher<arg_type>() const {\
01513       return ::testing::Matcher<arg_type>(\
01514           new gmock_Impl<arg_type>(p0, p1));\
01515     }\
01516     name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
01517         p1(gmock_p1) {\
01518     }\
01519     p0##_type p0;\
01520     p1##_type p1;\
01521    private:\
01522     GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
01523   };\
01524   template <typename p0##_type, typename p1##_type>\
01525   inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
01526       p1##_type p1) {\
01527     return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
01528   }\
01529   template <typename p0##_type, typename p1##_type>\
01530   template <typename arg_type>\
01531   bool name##MatcherP2<p0##_type, \
01532       p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01533       arg_type arg, \
01534       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01535           const
01536 
01537 #define MATCHER_P3(name, p0, p1, p2, description)\
01538   template <typename p0##_type, typename p1##_type, typename p2##_type>\
01539   class name##MatcherP3 {\
01540    public:\
01541     template <typename arg_type>\
01542     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01543      public:\
01544       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
01545            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
01546       virtual bool MatchAndExplain(\
01547           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01548       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01549         *gmock_os << FormatDescription(false);\
01550       }\
01551       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01552         *gmock_os << FormatDescription(true);\
01553       }\
01554       p0##_type p0;\
01555       p1##_type p1;\
01556       p2##_type p2;\
01557      private:\
01558       ::testing::internal::string FormatDescription(bool negation) const {\
01559         const ::testing::internal::string gmock_description = (description);\
01560         if (!gmock_description.empty())\
01561           return gmock_description;\
01562         return ::testing::internal::FormatMatcherDescription(\
01563             negation, #name, \
01564             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01565                 ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
01566                     p2)));\
01567       }\
01568       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01569     };\
01570     template <typename arg_type>\
01571     operator ::testing::Matcher<arg_type>() const {\
01572       return ::testing::Matcher<arg_type>(\
01573           new gmock_Impl<arg_type>(p0, p1, p2));\
01574     }\
01575     name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
01576         p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
01577     }\
01578     p0##_type p0;\
01579     p1##_type p1;\
01580     p2##_type p2;\
01581    private:\
01582     GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
01583   };\
01584   template <typename p0##_type, typename p1##_type, typename p2##_type>\
01585   inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
01586       p1##_type p1, p2##_type p2) {\
01587     return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
01588   }\
01589   template <typename p0##_type, typename p1##_type, typename p2##_type>\
01590   template <typename arg_type>\
01591   bool name##MatcherP3<p0##_type, p1##_type, \
01592       p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01593       arg_type arg, \
01594       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01595           const
01596 
01597 #define MATCHER_P4(name, p0, p1, p2, p3, description)\
01598   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01599       typename p3##_type>\
01600   class name##MatcherP4 {\
01601    public:\
01602     template <typename arg_type>\
01603     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01604      public:\
01605       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
01606           p3##_type gmock_p3)\
01607            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
01608       virtual bool MatchAndExplain(\
01609           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01610       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01611         *gmock_os << FormatDescription(false);\
01612       }\
01613       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01614         *gmock_os << FormatDescription(true);\
01615       }\
01616       p0##_type p0;\
01617       p1##_type p1;\
01618       p2##_type p2;\
01619       p3##_type p3;\
01620      private:\
01621       ::testing::internal::string FormatDescription(bool negation) const {\
01622         const ::testing::internal::string gmock_description = (description);\
01623         if (!gmock_description.empty())\
01624           return gmock_description;\
01625         return ::testing::internal::FormatMatcherDescription(\
01626             negation, #name, \
01627             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01628                 ::testing::tuple<p0##_type, p1##_type, p2##_type, \
01629                     p3##_type>(p0, p1, p2, p3)));\
01630       }\
01631       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01632     };\
01633     template <typename arg_type>\
01634     operator ::testing::Matcher<arg_type>() const {\
01635       return ::testing::Matcher<arg_type>(\
01636           new gmock_Impl<arg_type>(p0, p1, p2, p3));\
01637     }\
01638     name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
01639         p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
01640         p2(gmock_p2), p3(gmock_p3) {\
01641     }\
01642     p0##_type p0;\
01643     p1##_type p1;\
01644     p2##_type p2;\
01645     p3##_type p3;\
01646    private:\
01647     GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
01648   };\
01649   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01650       typename p3##_type>\
01651   inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
01652       p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
01653       p3##_type p3) {\
01654     return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
01655         p1, p2, p3);\
01656   }\
01657   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01658       typename p3##_type>\
01659   template <typename arg_type>\
01660   bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
01661       p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01662       arg_type arg, \
01663       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01664           const
01665 
01666 #define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
01667   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01668       typename p3##_type, typename p4##_type>\
01669   class name##MatcherP5 {\
01670    public:\
01671     template <typename arg_type>\
01672     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01673      public:\
01674       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
01675           p3##_type gmock_p3, p4##_type gmock_p4)\
01676            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
01677                p4(gmock_p4) {}\
01678       virtual bool MatchAndExplain(\
01679           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01680       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01681         *gmock_os << FormatDescription(false);\
01682       }\
01683       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01684         *gmock_os << FormatDescription(true);\
01685       }\
01686       p0##_type p0;\
01687       p1##_type p1;\
01688       p2##_type p2;\
01689       p3##_type p3;\
01690       p4##_type p4;\
01691      private:\
01692       ::testing::internal::string FormatDescription(bool negation) const {\
01693         const ::testing::internal::string gmock_description = (description);\
01694         if (!gmock_description.empty())\
01695           return gmock_description;\
01696         return ::testing::internal::FormatMatcherDescription(\
01697             negation, #name, \
01698             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01699                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
01700                     p4##_type>(p0, p1, p2, p3, p4)));\
01701       }\
01702       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01703     };\
01704     template <typename arg_type>\
01705     operator ::testing::Matcher<arg_type>() const {\
01706       return ::testing::Matcher<arg_type>(\
01707           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
01708     }\
01709     name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
01710         p2##_type gmock_p2, p3##_type gmock_p3, \
01711         p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
01712         p3(gmock_p3), p4(gmock_p4) {\
01713     }\
01714     p0##_type p0;\
01715     p1##_type p1;\
01716     p2##_type p2;\
01717     p3##_type p3;\
01718     p4##_type p4;\
01719    private:\
01720     GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
01721   };\
01722   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01723       typename p3##_type, typename p4##_type>\
01724   inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
01725       p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
01726       p4##_type p4) {\
01727     return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
01728         p4##_type>(p0, p1, p2, p3, p4);\
01729   }\
01730   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01731       typename p3##_type, typename p4##_type>\
01732   template <typename arg_type>\
01733   bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
01734       p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01735       arg_type arg, \
01736       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01737           const
01738 
01739 #define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
01740   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01741       typename p3##_type, typename p4##_type, typename p5##_type>\
01742   class name##MatcherP6 {\
01743    public:\
01744     template <typename arg_type>\
01745     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01746      public:\
01747       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
01748           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
01749            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
01750                p4(gmock_p4), p5(gmock_p5) {}\
01751       virtual bool MatchAndExplain(\
01752           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01753       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01754         *gmock_os << FormatDescription(false);\
01755       }\
01756       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01757         *gmock_os << FormatDescription(true);\
01758       }\
01759       p0##_type p0;\
01760       p1##_type p1;\
01761       p2##_type p2;\
01762       p3##_type p3;\
01763       p4##_type p4;\
01764       p5##_type p5;\
01765      private:\
01766       ::testing::internal::string FormatDescription(bool negation) const {\
01767         const ::testing::internal::string gmock_description = (description);\
01768         if (!gmock_description.empty())\
01769           return gmock_description;\
01770         return ::testing::internal::FormatMatcherDescription(\
01771             negation, #name, \
01772             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01773                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
01774                     p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
01775       }\
01776       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01777     };\
01778     template <typename arg_type>\
01779     operator ::testing::Matcher<arg_type>() const {\
01780       return ::testing::Matcher<arg_type>(\
01781           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
01782     }\
01783     name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
01784         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
01785         p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
01786         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
01787     }\
01788     p0##_type p0;\
01789     p1##_type p1;\
01790     p2##_type p2;\
01791     p3##_type p3;\
01792     p4##_type p4;\
01793     p5##_type p5;\
01794    private:\
01795     GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
01796   };\
01797   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01798       typename p3##_type, typename p4##_type, typename p5##_type>\
01799   inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
01800       p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
01801       p3##_type p3, p4##_type p4, p5##_type p5) {\
01802     return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
01803         p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
01804   }\
01805   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01806       typename p3##_type, typename p4##_type, typename p5##_type>\
01807   template <typename arg_type>\
01808   bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
01809       p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01810       arg_type arg, \
01811       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01812           const
01813 
01814 #define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
01815   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01816       typename p3##_type, typename p4##_type, typename p5##_type, \
01817       typename p6##_type>\
01818   class name##MatcherP7 {\
01819    public:\
01820     template <typename arg_type>\
01821     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01822      public:\
01823       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
01824           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
01825           p6##_type gmock_p6)\
01826            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
01827                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
01828       virtual bool MatchAndExplain(\
01829           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01830       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01831         *gmock_os << FormatDescription(false);\
01832       }\
01833       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01834         *gmock_os << FormatDescription(true);\
01835       }\
01836       p0##_type p0;\
01837       p1##_type p1;\
01838       p2##_type p2;\
01839       p3##_type p3;\
01840       p4##_type p4;\
01841       p5##_type p5;\
01842       p6##_type p6;\
01843      private:\
01844       ::testing::internal::string FormatDescription(bool negation) const {\
01845         const ::testing::internal::string gmock_description = (description);\
01846         if (!gmock_description.empty())\
01847           return gmock_description;\
01848         return ::testing::internal::FormatMatcherDescription(\
01849             negation, #name, \
01850             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01851                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
01852                     p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
01853                     p6)));\
01854       }\
01855       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01856     };\
01857     template <typename arg_type>\
01858     operator ::testing::Matcher<arg_type>() const {\
01859       return ::testing::Matcher<arg_type>(\
01860           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
01861     }\
01862     name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
01863         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
01864         p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
01865         p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
01866         p6(gmock_p6) {\
01867     }\
01868     p0##_type p0;\
01869     p1##_type p1;\
01870     p2##_type p2;\
01871     p3##_type p3;\
01872     p4##_type p4;\
01873     p5##_type p5;\
01874     p6##_type p6;\
01875    private:\
01876     GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
01877   };\
01878   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01879       typename p3##_type, typename p4##_type, typename p5##_type, \
01880       typename p6##_type>\
01881   inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
01882       p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
01883       p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
01884       p6##_type p6) {\
01885     return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
01886         p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
01887   }\
01888   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01889       typename p3##_type, typename p4##_type, typename p5##_type, \
01890       typename p6##_type>\
01891   template <typename arg_type>\
01892   bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
01893       p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01894       arg_type arg, \
01895       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01896           const
01897 
01898 #define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
01899   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01900       typename p3##_type, typename p4##_type, typename p5##_type, \
01901       typename p6##_type, typename p7##_type>\
01902   class name##MatcherP8 {\
01903    public:\
01904     template <typename arg_type>\
01905     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01906      public:\
01907       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
01908           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
01909           p6##_type gmock_p6, p7##_type gmock_p7)\
01910            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
01911                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
01912       virtual bool MatchAndExplain(\
01913           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
01914       virtual void DescribeTo(::std::ostream* gmock_os) const {\
01915         *gmock_os << FormatDescription(false);\
01916       }\
01917       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
01918         *gmock_os << FormatDescription(true);\
01919       }\
01920       p0##_type p0;\
01921       p1##_type p1;\
01922       p2##_type p2;\
01923       p3##_type p3;\
01924       p4##_type p4;\
01925       p5##_type p5;\
01926       p6##_type p6;\
01927       p7##_type p7;\
01928      private:\
01929       ::testing::internal::string FormatDescription(bool negation) const {\
01930         const ::testing::internal::string gmock_description = (description);\
01931         if (!gmock_description.empty())\
01932           return gmock_description;\
01933         return ::testing::internal::FormatMatcherDescription(\
01934             negation, #name, \
01935             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
01936                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
01937                     p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
01938                     p3, p4, p5, p6, p7)));\
01939       }\
01940       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
01941     };\
01942     template <typename arg_type>\
01943     operator ::testing::Matcher<arg_type>() const {\
01944       return ::testing::Matcher<arg_type>(\
01945           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
01946     }\
01947     name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
01948         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
01949         p5##_type gmock_p5, p6##_type gmock_p6, \
01950         p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
01951         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
01952         p7(gmock_p7) {\
01953     }\
01954     p0##_type p0;\
01955     p1##_type p1;\
01956     p2##_type p2;\
01957     p3##_type p3;\
01958     p4##_type p4;\
01959     p5##_type p5;\
01960     p6##_type p6;\
01961     p7##_type p7;\
01962    private:\
01963     GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
01964   };\
01965   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01966       typename p3##_type, typename p4##_type, typename p5##_type, \
01967       typename p6##_type, typename p7##_type>\
01968   inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
01969       p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
01970       p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
01971       p6##_type p6, p7##_type p7) {\
01972     return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
01973         p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
01974         p6, p7);\
01975   }\
01976   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01977       typename p3##_type, typename p4##_type, typename p5##_type, \
01978       typename p6##_type, typename p7##_type>\
01979   template <typename arg_type>\
01980   bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
01981       p5##_type, p6##_type, \
01982       p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
01983       arg_type arg, \
01984       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
01985           const
01986 
01987 #define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
01988   template <typename p0##_type, typename p1##_type, typename p2##_type, \
01989       typename p3##_type, typename p4##_type, typename p5##_type, \
01990       typename p6##_type, typename p7##_type, typename p8##_type>\
01991   class name##MatcherP9 {\
01992    public:\
01993     template <typename arg_type>\
01994     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
01995      public:\
01996       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
01997           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
01998           p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
01999            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
02000                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
02001                p8(gmock_p8) {}\
02002       virtual bool MatchAndExplain(\
02003           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
02004       virtual void DescribeTo(::std::ostream* gmock_os) const {\
02005         *gmock_os << FormatDescription(false);\
02006       }\
02007       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
02008         *gmock_os << FormatDescription(true);\
02009       }\
02010       p0##_type p0;\
02011       p1##_type p1;\
02012       p2##_type p2;\
02013       p3##_type p3;\
02014       p4##_type p4;\
02015       p5##_type p5;\
02016       p6##_type p6;\
02017       p7##_type p7;\
02018       p8##_type p8;\
02019      private:\
02020       ::testing::internal::string FormatDescription(bool negation) const {\
02021         const ::testing::internal::string gmock_description = (description);\
02022         if (!gmock_description.empty())\
02023           return gmock_description;\
02024         return ::testing::internal::FormatMatcherDescription(\
02025             negation, #name, \
02026             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
02027                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
02028                     p4##_type, p5##_type, p6##_type, p7##_type, \
02029                     p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
02030       }\
02031       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
02032     };\
02033     template <typename arg_type>\
02034     operator ::testing::Matcher<arg_type>() const {\
02035       return ::testing::Matcher<arg_type>(\
02036           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
02037     }\
02038     name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
02039         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
02040         p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
02041         p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
02042         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
02043         p8(gmock_p8) {\
02044     }\
02045     p0##_type p0;\
02046     p1##_type p1;\
02047     p2##_type p2;\
02048     p3##_type p3;\
02049     p4##_type p4;\
02050     p5##_type p5;\
02051     p6##_type p6;\
02052     p7##_type p7;\
02053     p8##_type p8;\
02054    private:\
02055     GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
02056   };\
02057   template <typename p0##_type, typename p1##_type, typename p2##_type, \
02058       typename p3##_type, typename p4##_type, typename p5##_type, \
02059       typename p6##_type, typename p7##_type, typename p8##_type>\
02060   inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
02061       p4##_type, p5##_type, p6##_type, p7##_type, \
02062       p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
02063       p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
02064       p8##_type p8) {\
02065     return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
02066         p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
02067         p3, p4, p5, p6, p7, p8);\
02068   }\
02069   template <typename p0##_type, typename p1##_type, typename p2##_type, \
02070       typename p3##_type, typename p4##_type, typename p5##_type, \
02071       typename p6##_type, typename p7##_type, typename p8##_type>\
02072   template <typename arg_type>\
02073   bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
02074       p5##_type, p6##_type, p7##_type, \
02075       p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
02076       arg_type arg, \
02077       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
02078           const
02079 
02080 #define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
02081   template <typename p0##_type, typename p1##_type, typename p2##_type, \
02082       typename p3##_type, typename p4##_type, typename p5##_type, \
02083       typename p6##_type, typename p7##_type, typename p8##_type, \
02084       typename p9##_type>\
02085   class name##MatcherP10 {\
02086    public:\
02087     template <typename arg_type>\
02088     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
02089      public:\
02090       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
02091           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
02092           p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
02093           p9##_type gmock_p9)\
02094            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
02095                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
02096                p8(gmock_p8), p9(gmock_p9) {}\
02097       virtual bool MatchAndExplain(\
02098           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
02099       virtual void DescribeTo(::std::ostream* gmock_os) const {\
02100         *gmock_os << FormatDescription(false);\
02101       }\
02102       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
02103         *gmock_os << FormatDescription(true);\
02104       }\
02105       p0##_type p0;\
02106       p1##_type p1;\
02107       p2##_type p2;\
02108       p3##_type p3;\
02109       p4##_type p4;\
02110       p5##_type p5;\
02111       p6##_type p6;\
02112       p7##_type p7;\
02113       p8##_type p8;\
02114       p9##_type p9;\
02115      private:\
02116       ::testing::internal::string FormatDescription(bool negation) const {\
02117         const ::testing::internal::string gmock_description = (description);\
02118         if (!gmock_description.empty())\
02119           return gmock_description;\
02120         return ::testing::internal::FormatMatcherDescription(\
02121             negation, #name, \
02122             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
02123                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
02124                     p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
02125                     p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
02126       }\
02127       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
02128     };\
02129     template <typename arg_type>\
02130     operator ::testing::Matcher<arg_type>() const {\
02131       return ::testing::Matcher<arg_type>(\
02132           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
02133     }\
02134     name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
02135         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
02136         p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
02137         p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
02138         p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
02139         p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\
02140     }\
02141     p0##_type p0;\
02142     p1##_type p1;\
02143     p2##_type p2;\
02144     p3##_type p3;\
02145     p4##_type p4;\
02146     p5##_type p5;\
02147     p6##_type p6;\
02148     p7##_type p7;\
02149     p8##_type p8;\
02150     p9##_type p9;\
02151    private:\
02152     GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
02153   };\
02154   template <typename p0##_type, typename p1##_type, typename p2##_type, \
02155       typename p3##_type, typename p4##_type, typename p5##_type, \
02156       typename p6##_type, typename p7##_type, typename p8##_type, \
02157       typename p9##_type>\
02158   inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
02159       p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
02160       p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
02161       p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
02162       p9##_type p9) {\
02163     return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
02164         p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
02165         p1, p2, p3, p4, p5, p6, p7, p8, p9);\
02166   }\
02167   template <typename p0##_type, typename p1##_type, typename p2##_type, \
02168       typename p3##_type, typename p4##_type, typename p5##_type, \
02169       typename p6##_type, typename p7##_type, typename p8##_type, \
02170       typename p9##_type>\
02171   template <typename arg_type>\
02172   bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
02173       p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
02174       p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
02175       arg_type arg, \
02176       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
02177           const
02178 
02179 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_