1 // This file was GENERATED by command:
2 //     pump.py gmock-generated-matchers.h.pump
3 // DO NOT EDIT BY HAND!!!
4 
5 // Copyright 2008, Google Inc.
6 // All rights reserved.
7 //
8 // Redistribution and use in source and binary forms, with or without
9 // modification, are permitted provided that the following conditions are
10 // met:
11 //
12 //     * Redistributions of source code must retain the above copyright
13 // notice, this list of conditions and the following disclaimer.
14 //     * Redistributions in binary form must reproduce the above
15 // copyright notice, this list of conditions and the following disclaimer
16 // in the documentation and/or other materials provided with the
17 // distribution.
18 //     * Neither the name of Google Inc. nor the names of its
19 // contributors may be used to endorse or promote products derived from
20 // this software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 
34 // Google Mock - a framework for writing C++ mock classes.
35 //
36 // This file implements some commonly used variadic matchers.
37 
38 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
39 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
40 
41 #include <iterator>
42 #include <sstream>
43 #include <string>
44 #include <vector>
45 #include "gmock/gmock-matchers.h"
46 
47 namespace testing {
48 namespace internal {
49 
50 // The type of the i-th (0-based) field of Tuple.
51 #define GMOCK_FIELD_TYPE_(Tuple, i) \
52     typename ::testing::tuple_element<i, Tuple>::type
53 
54 // TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
55 // tuple of type Tuple.  It has two members:
56 //
57 //   type: a tuple type whose i-th field is the ki-th field of Tuple.
58 //   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
59 //
60 // For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
61 //
62 //   type is tuple<int, bool>, and
63 //   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
64 
65 template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
66     int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
67     int k9 = -1>
68 class TupleFields;
69 
70 // This generic version is used when there are 10 selectors.
71 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
72     int k7, int k8, int k9>
73 class TupleFields {
74  public:
75   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
76       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
77       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
78       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
79       GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
80       GMOCK_FIELD_TYPE_(Tuple, k9)> type;
GetSelectedFields(const Tuple & t)81   static type GetSelectedFields(const Tuple& t) {
82     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
83         get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
84   }
85 };
86 
87 // The following specialization is used for 0 ~ 9 selectors.
88 
89 template <class Tuple>
90 class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
91  public:
92   typedef ::testing::tuple<> type;
GetSelectedFields(const Tuple &)93   static type GetSelectedFields(const Tuple& /* t */) {
94     return type();
95   }
96 };
97 
98 template <class Tuple, int k0>
99 class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
100  public:
101   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
GetSelectedFields(const Tuple & t)102   static type GetSelectedFields(const Tuple& t) {
103     return type(get<k0>(t));
104   }
105 };
106 
107 template <class Tuple, int k0, int k1>
108 class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
109  public:
110   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
111       GMOCK_FIELD_TYPE_(Tuple, k1)> type;
GetSelectedFields(const Tuple & t)112   static type GetSelectedFields(const Tuple& t) {
113     return type(get<k0>(t), get<k1>(t));
114   }
115 };
116 
117 template <class Tuple, int k0, int k1, int k2>
118 class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
119  public:
120   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
121       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
GetSelectedFields(const Tuple & t)122   static type GetSelectedFields(const Tuple& t) {
123     return type(get<k0>(t), get<k1>(t), get<k2>(t));
124   }
125 };
126 
127 template <class Tuple, int k0, int k1, int k2, int k3>
128 class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
129  public:
130   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
131       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
132       GMOCK_FIELD_TYPE_(Tuple, k3)> type;
GetSelectedFields(const Tuple & t)133   static type GetSelectedFields(const Tuple& t) {
134     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
135   }
136 };
137 
138 template <class Tuple, int k0, int k1, int k2, int k3, int k4>
139 class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
140  public:
141   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
142       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
143       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
GetSelectedFields(const Tuple & t)144   static type GetSelectedFields(const Tuple& t) {
145     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
146   }
147 };
148 
149 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
150 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
151  public:
152   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
153       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
154       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
155       GMOCK_FIELD_TYPE_(Tuple, k5)> type;
GetSelectedFields(const Tuple & t)156   static type GetSelectedFields(const Tuple& t) {
157     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
158         get<k5>(t));
159   }
160 };
161 
162 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
163 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
164  public:
165   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
166       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
167       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
168       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
GetSelectedFields(const Tuple & t)169   static type GetSelectedFields(const Tuple& t) {
170     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
171         get<k5>(t), get<k6>(t));
172   }
173 };
174 
175 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
176     int k7>
177 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
178  public:
179   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
180       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
181       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
182       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
183       GMOCK_FIELD_TYPE_(Tuple, k7)> type;
GetSelectedFields(const Tuple & t)184   static type GetSelectedFields(const Tuple& t) {
185     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
186         get<k5>(t), get<k6>(t), get<k7>(t));
187   }
188 };
189 
190 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
191     int k7, int k8>
192 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
193  public:
194   typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
195       GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
196       GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
197       GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
198       GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
GetSelectedFields(const Tuple & t)199   static type GetSelectedFields(const Tuple& t) {
200     return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
201         get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
202   }
203 };
204 
205 #undef GMOCK_FIELD_TYPE_
206 
207 // Implements the Args() matcher.
208 template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
209     int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
210     int k9 = -1>
211 class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
212  public:
213   // ArgsTuple may have top-level const or reference modifiers.
214   typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
215   typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
216       k6, k7, k8, k9>::type SelectedArgs;
217   typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
218 
219   template <typename InnerMatcher>
ArgsMatcherImpl(const InnerMatcher & inner_matcher)220   explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
221       : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
222 
MatchAndExplain(ArgsTuple args,MatchResultListener * listener)223   virtual bool MatchAndExplain(ArgsTuple args,
224                                MatchResultListener* listener) const {
225     const SelectedArgs& selected_args = GetSelectedArgs(args);
226     if (!listener->IsInterested())
227       return inner_matcher_.Matches(selected_args);
228 
229     PrintIndices(listener->stream());
230     *listener << "are " << PrintToString(selected_args);
231 
232     StringMatchResultListener inner_listener;
233     const bool match = inner_matcher_.MatchAndExplain(selected_args,
234                                                       &inner_listener);
235     PrintIfNotEmpty(inner_listener.str(), listener->stream());
236     return match;
237   }
238 
DescribeTo(::std::ostream * os)239   virtual void DescribeTo(::std::ostream* os) const {
240     *os << "are a tuple ";
241     PrintIndices(os);
242     inner_matcher_.DescribeTo(os);
243   }
244 
DescribeNegationTo(::std::ostream * os)245   virtual void DescribeNegationTo(::std::ostream* os) const {
246     *os << "are a tuple ";
247     PrintIndices(os);
248     inner_matcher_.DescribeNegationTo(os);
249   }
250 
251  private:
GetSelectedArgs(ArgsTuple args)252   static SelectedArgs GetSelectedArgs(ArgsTuple args) {
253     return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
254         k9>::GetSelectedFields(args);
255   }
256 
257   // Prints the indices of the selected fields.
PrintIndices(::std::ostream * os)258   static void PrintIndices(::std::ostream* os) {
259     *os << "whose fields (";
260     const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
261     for (int i = 0; i < 10; i++) {
262       if (indices[i] < 0)
263         break;
264 
265       if (i >= 1)
266         *os << ", ";
267 
268       *os << "#" << indices[i];
269     }
270     *os << ") ";
271   }
272 
273   const MonomorphicInnerMatcher inner_matcher_;
274 
275   GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
276 };
277 
278 template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
279     int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
280     int k8 = -1, int k9 = -1>
281 class ArgsMatcher {
282  public:
ArgsMatcher(const InnerMatcher & inner_matcher)283   explicit ArgsMatcher(const InnerMatcher& inner_matcher)
284       : inner_matcher_(inner_matcher) {}
285 
286   template <typename ArgsTuple>
287   operator Matcher<ArgsTuple>() const {
288     return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
289         k6, k7, k8, k9>(inner_matcher_));
290   }
291 
292  private:
293   const InnerMatcher inner_matcher_;
294 
295   GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
296 };
297 
298 // A set of metafunctions for computing the result type of AllOf.
299 // AllOf(m1, ..., mN) returns
300 // AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
301 
302 // Although AllOf isn't defined for one argument, AllOfResult1 is defined
303 // to simplify the implementation.
304 template <typename M1>
305 struct AllOfResult1 {
306   typedef M1 type;
307 };
308 
309 template <typename M1, typename M2>
310 struct AllOfResult2 {
311   typedef BothOfMatcher<
312       typename AllOfResult1<M1>::type,
313       typename AllOfResult1<M2>::type
314   > type;
315 };
316 
317 template <typename M1, typename M2, typename M3>
318 struct AllOfResult3 {
319   typedef BothOfMatcher<
320       typename AllOfResult1<M1>::type,
321       typename AllOfResult2<M2, M3>::type
322   > type;
323 };
324 
325 template <typename M1, typename M2, typename M3, typename M4>
326 struct AllOfResult4 {
327   typedef BothOfMatcher<
328       typename AllOfResult2<M1, M2>::type,
329       typename AllOfResult2<M3, M4>::type
330   > type;
331 };
332 
333 template <typename M1, typename M2, typename M3, typename M4, typename M5>
334 struct AllOfResult5 {
335   typedef BothOfMatcher<
336       typename AllOfResult2<M1, M2>::type,
337       typename AllOfResult3<M3, M4, M5>::type
338   > type;
339 };
340 
341 template <typename M1, typename M2, typename M3, typename M4, typename M5,
342     typename M6>
343 struct AllOfResult6 {
344   typedef BothOfMatcher<
345       typename AllOfResult3<M1, M2, M3>::type,
346       typename AllOfResult3<M4, M5, M6>::type
347   > type;
348 };
349 
350 template <typename M1, typename M2, typename M3, typename M4, typename M5,
351     typename M6, typename M7>
352 struct AllOfResult7 {
353   typedef BothOfMatcher<
354       typename AllOfResult3<M1, M2, M3>::type,
355       typename AllOfResult4<M4, M5, M6, M7>::type
356   > type;
357 };
358 
359 template <typename M1, typename M2, typename M3, typename M4, typename M5,
360     typename M6, typename M7, typename M8>
361 struct AllOfResult8 {
362   typedef BothOfMatcher<
363       typename AllOfResult4<M1, M2, M3, M4>::type,
364       typename AllOfResult4<M5, M6, M7, M8>::type
365   > type;
366 };
367 
368 template <typename M1, typename M2, typename M3, typename M4, typename M5,
369     typename M6, typename M7, typename M8, typename M9>
370 struct AllOfResult9 {
371   typedef BothOfMatcher<
372       typename AllOfResult4<M1, M2, M3, M4>::type,
373       typename AllOfResult5<M5, M6, M7, M8, M9>::type
374   > type;
375 };
376 
377 template <typename M1, typename M2, typename M3, typename M4, typename M5,
378     typename M6, typename M7, typename M8, typename M9, typename M10>
379 struct AllOfResult10 {
380   typedef BothOfMatcher<
381       typename AllOfResult5<M1, M2, M3, M4, M5>::type,
382       typename AllOfResult5<M6, M7, M8, M9, M10>::type
383   > type;
384 };
385 
386 // A set of metafunctions for computing the result type of AnyOf.
387 // AnyOf(m1, ..., mN) returns
388 // AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
389 
390 // Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
391 // to simplify the implementation.
392 template <typename M1>
393 struct AnyOfResult1 {
394   typedef M1 type;
395 };
396 
397 template <typename M1, typename M2>
398 struct AnyOfResult2 {
399   typedef EitherOfMatcher<
400       typename AnyOfResult1<M1>::type,
401       typename AnyOfResult1<M2>::type
402   > type;
403 };
404 
405 template <typename M1, typename M2, typename M3>
406 struct AnyOfResult3 {
407   typedef EitherOfMatcher<
408       typename AnyOfResult1<M1>::type,
409       typename AnyOfResult2<M2, M3>::type
410   > type;
411 };
412 
413 template <typename M1, typename M2, typename M3, typename M4>
414 struct AnyOfResult4 {
415   typedef EitherOfMatcher<
416       typename AnyOfResult2<M1, M2>::type,
417       typename AnyOfResult2<M3, M4>::type
418   > type;
419 };
420 
421 template <typename M1, typename M2, typename M3, typename M4, typename M5>
422 struct AnyOfResult5 {
423   typedef EitherOfMatcher<
424       typename AnyOfResult2<M1, M2>::type,
425       typename AnyOfResult3<M3, M4, M5>::type
426   > type;
427 };
428 
429 template <typename M1, typename M2, typename M3, typename M4, typename M5,
430     typename M6>
431 struct AnyOfResult6 {
432   typedef EitherOfMatcher<
433       typename AnyOfResult3<M1, M2, M3>::type,
434       typename AnyOfResult3<M4, M5, M6>::type
435   > type;
436 };
437 
438 template <typename M1, typename M2, typename M3, typename M4, typename M5,
439     typename M6, typename M7>
440 struct AnyOfResult7 {
441   typedef EitherOfMatcher<
442       typename AnyOfResult3<M1, M2, M3>::type,
443       typename AnyOfResult4<M4, M5, M6, M7>::type
444   > type;
445 };
446 
447 template <typename M1, typename M2, typename M3, typename M4, typename M5,
448     typename M6, typename M7, typename M8>
449 struct AnyOfResult8 {
450   typedef EitherOfMatcher<
451       typename AnyOfResult4<M1, M2, M3, M4>::type,
452       typename AnyOfResult4<M5, M6, M7, M8>::type
453   > type;
454 };
455 
456 template <typename M1, typename M2, typename M3, typename M4, typename M5,
457     typename M6, typename M7, typename M8, typename M9>
458 struct AnyOfResult9 {
459   typedef EitherOfMatcher<
460       typename AnyOfResult4<M1, M2, M3, M4>::type,
461       typename AnyOfResult5<M5, M6, M7, M8, M9>::type
462   > type;
463 };
464 
465 template <typename M1, typename M2, typename M3, typename M4, typename M5,
466     typename M6, typename M7, typename M8, typename M9, typename M10>
467 struct AnyOfResult10 {
468   typedef EitherOfMatcher<
469       typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
470       typename AnyOfResult5<M6, M7, M8, M9, M10>::type
471   > type;
472 };
473 
474 }  // namespace internal
475 
476 // Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
477 // fields of it matches a_matcher.  C++ doesn't support default
478 // arguments for function templates, so we have to overload it.
479 template <typename InnerMatcher>
480 inline internal::ArgsMatcher<InnerMatcher>
Args(const InnerMatcher & matcher)481 Args(const InnerMatcher& matcher) {
482   return internal::ArgsMatcher<InnerMatcher>(matcher);
483 }
484 
485 template <int k1, typename InnerMatcher>
486 inline internal::ArgsMatcher<InnerMatcher, k1>
Args(const InnerMatcher & matcher)487 Args(const InnerMatcher& matcher) {
488   return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
489 }
490 
491 template <int k1, int k2, typename InnerMatcher>
492 inline internal::ArgsMatcher<InnerMatcher, k1, k2>
Args(const InnerMatcher & matcher)493 Args(const InnerMatcher& matcher) {
494   return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
495 }
496 
497 template <int k1, int k2, int k3, typename InnerMatcher>
498 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
Args(const InnerMatcher & matcher)499 Args(const InnerMatcher& matcher) {
500   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
501 }
502 
503 template <int k1, int k2, int k3, int k4, typename InnerMatcher>
504 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
Args(const InnerMatcher & matcher)505 Args(const InnerMatcher& matcher) {
506   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
507 }
508 
509 template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
510 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
Args(const InnerMatcher & matcher)511 Args(const InnerMatcher& matcher) {
512   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
513 }
514 
515 template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
516 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
Args(const InnerMatcher & matcher)517 Args(const InnerMatcher& matcher) {
518   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
519 }
520 
521 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
522     typename InnerMatcher>
523 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
Args(const InnerMatcher & matcher)524 Args(const InnerMatcher& matcher) {
525   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
526       k7>(matcher);
527 }
528 
529 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
530     typename InnerMatcher>
531 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
Args(const InnerMatcher & matcher)532 Args(const InnerMatcher& matcher) {
533   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
534       k8>(matcher);
535 }
536 
537 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
538     int k9, typename InnerMatcher>
539 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
Args(const InnerMatcher & matcher)540 Args(const InnerMatcher& matcher) {
541   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
542       k9>(matcher);
543 }
544 
545 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
546     int k9, int k10, typename InnerMatcher>
547 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
548     k10>
Args(const InnerMatcher & matcher)549 Args(const InnerMatcher& matcher) {
550   return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
551       k9, k10>(matcher);
552 }
553 
554 // ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
555 // n elements, where the i-th element in the container must
556 // match the i-th argument in the list.  Each argument of
557 // ElementsAre() can be either a value or a matcher.  We support up to
558 // 10 arguments.
559 //
560 // The use of DecayArray in the implementation allows ElementsAre()
561 // to accept string literals, whose type is const char[N], but we
562 // want to treat them as const char*.
563 //
564 // NOTE: Since ElementsAre() cares about the order of the elements, it
565 // must not be used with containers whose elements's order is
566 // undefined (e.g. hash_map).
567 
568 inline internal::ElementsAreMatcher<
569     ::testing::tuple<> >
ElementsAre()570 ElementsAre() {
571   typedef ::testing::tuple<> Args;
572   return internal::ElementsAreMatcher<Args>(Args());
573 }
574 
575 template <typename T1>
576 inline internal::ElementsAreMatcher<
577     ::testing::tuple<
578         typename internal::DecayArray<T1>::type> >
ElementsAre(const T1 & e1)579 ElementsAre(const T1& e1) {
580   typedef ::testing::tuple<
581       typename internal::DecayArray<T1>::type> Args;
582   return internal::ElementsAreMatcher<Args>(Args(e1));
583 }
584 
585 template <typename T1, typename T2>
586 inline internal::ElementsAreMatcher<
587     ::testing::tuple<
588         typename internal::DecayArray<T1>::type,
589         typename internal::DecayArray<T2>::type> >
ElementsAre(const T1 & e1,const T2 & e2)590 ElementsAre(const T1& e1, const T2& e2) {
591   typedef ::testing::tuple<
592       typename internal::DecayArray<T1>::type,
593       typename internal::DecayArray<T2>::type> Args;
594   return internal::ElementsAreMatcher<Args>(Args(e1, e2));
595 }
596 
597 template <typename T1, typename T2, typename T3>
598 inline internal::ElementsAreMatcher<
599     ::testing::tuple<
600         typename internal::DecayArray<T1>::type,
601         typename internal::DecayArray<T2>::type,
602         typename internal::DecayArray<T3>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3)603 ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
604   typedef ::testing::tuple<
605       typename internal::DecayArray<T1>::type,
606       typename internal::DecayArray<T2>::type,
607       typename internal::DecayArray<T3>::type> Args;
608   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
609 }
610 
611 template <typename T1, typename T2, typename T3, typename T4>
612 inline internal::ElementsAreMatcher<
613     ::testing::tuple<
614         typename internal::DecayArray<T1>::type,
615         typename internal::DecayArray<T2>::type,
616         typename internal::DecayArray<T3>::type,
617         typename internal::DecayArray<T4>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4)618 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
619   typedef ::testing::tuple<
620       typename internal::DecayArray<T1>::type,
621       typename internal::DecayArray<T2>::type,
622       typename internal::DecayArray<T3>::type,
623       typename internal::DecayArray<T4>::type> Args;
624   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
625 }
626 
627 template <typename T1, typename T2, typename T3, typename T4, typename T5>
628 inline internal::ElementsAreMatcher<
629     ::testing::tuple<
630         typename internal::DecayArray<T1>::type,
631         typename internal::DecayArray<T2>::type,
632         typename internal::DecayArray<T3>::type,
633         typename internal::DecayArray<T4>::type,
634         typename internal::DecayArray<T5>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5)635 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
636     const T5& e5) {
637   typedef ::testing::tuple<
638       typename internal::DecayArray<T1>::type,
639       typename internal::DecayArray<T2>::type,
640       typename internal::DecayArray<T3>::type,
641       typename internal::DecayArray<T4>::type,
642       typename internal::DecayArray<T5>::type> Args;
643   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
644 }
645 
646 template <typename T1, typename T2, typename T3, typename T4, typename T5,
647     typename T6>
648 inline internal::ElementsAreMatcher<
649     ::testing::tuple<
650         typename internal::DecayArray<T1>::type,
651         typename internal::DecayArray<T2>::type,
652         typename internal::DecayArray<T3>::type,
653         typename internal::DecayArray<T4>::type,
654         typename internal::DecayArray<T5>::type,
655         typename internal::DecayArray<T6>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6)656 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
657     const T5& e5, const T6& e6) {
658   typedef ::testing::tuple<
659       typename internal::DecayArray<T1>::type,
660       typename internal::DecayArray<T2>::type,
661       typename internal::DecayArray<T3>::type,
662       typename internal::DecayArray<T4>::type,
663       typename internal::DecayArray<T5>::type,
664       typename internal::DecayArray<T6>::type> Args;
665   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
666 }
667 
668 template <typename T1, typename T2, typename T3, typename T4, typename T5,
669     typename T6, typename T7>
670 inline internal::ElementsAreMatcher<
671     ::testing::tuple<
672         typename internal::DecayArray<T1>::type,
673         typename internal::DecayArray<T2>::type,
674         typename internal::DecayArray<T3>::type,
675         typename internal::DecayArray<T4>::type,
676         typename internal::DecayArray<T5>::type,
677         typename internal::DecayArray<T6>::type,
678         typename internal::DecayArray<T7>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7)679 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
680     const T5& e5, const T6& e6, const T7& e7) {
681   typedef ::testing::tuple<
682       typename internal::DecayArray<T1>::type,
683       typename internal::DecayArray<T2>::type,
684       typename internal::DecayArray<T3>::type,
685       typename internal::DecayArray<T4>::type,
686       typename internal::DecayArray<T5>::type,
687       typename internal::DecayArray<T6>::type,
688       typename internal::DecayArray<T7>::type> Args;
689   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
690 }
691 
692 template <typename T1, typename T2, typename T3, typename T4, typename T5,
693     typename T6, typename T7, typename T8>
694 inline internal::ElementsAreMatcher<
695     ::testing::tuple<
696         typename internal::DecayArray<T1>::type,
697         typename internal::DecayArray<T2>::type,
698         typename internal::DecayArray<T3>::type,
699         typename internal::DecayArray<T4>::type,
700         typename internal::DecayArray<T5>::type,
701         typename internal::DecayArray<T6>::type,
702         typename internal::DecayArray<T7>::type,
703         typename internal::DecayArray<T8>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8)704 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
705     const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
706   typedef ::testing::tuple<
707       typename internal::DecayArray<T1>::type,
708       typename internal::DecayArray<T2>::type,
709       typename internal::DecayArray<T3>::type,
710       typename internal::DecayArray<T4>::type,
711       typename internal::DecayArray<T5>::type,
712       typename internal::DecayArray<T6>::type,
713       typename internal::DecayArray<T7>::type,
714       typename internal::DecayArray<T8>::type> Args;
715   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
716       e8));
717 }
718 
719 template <typename T1, typename T2, typename T3, typename T4, typename T5,
720     typename T6, typename T7, typename T8, typename T9>
721 inline internal::ElementsAreMatcher<
722     ::testing::tuple<
723         typename internal::DecayArray<T1>::type,
724         typename internal::DecayArray<T2>::type,
725         typename internal::DecayArray<T3>::type,
726         typename internal::DecayArray<T4>::type,
727         typename internal::DecayArray<T5>::type,
728         typename internal::DecayArray<T6>::type,
729         typename internal::DecayArray<T7>::type,
730         typename internal::DecayArray<T8>::type,
731         typename internal::DecayArray<T9>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9)732 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
733     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
734   typedef ::testing::tuple<
735       typename internal::DecayArray<T1>::type,
736       typename internal::DecayArray<T2>::type,
737       typename internal::DecayArray<T3>::type,
738       typename internal::DecayArray<T4>::type,
739       typename internal::DecayArray<T5>::type,
740       typename internal::DecayArray<T6>::type,
741       typename internal::DecayArray<T7>::type,
742       typename internal::DecayArray<T8>::type,
743       typename internal::DecayArray<T9>::type> Args;
744   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
745       e8, e9));
746 }
747 
748 template <typename T1, typename T2, typename T3, typename T4, typename T5,
749     typename T6, typename T7, typename T8, typename T9, typename T10>
750 inline internal::ElementsAreMatcher<
751     ::testing::tuple<
752         typename internal::DecayArray<T1>::type,
753         typename internal::DecayArray<T2>::type,
754         typename internal::DecayArray<T3>::type,
755         typename internal::DecayArray<T4>::type,
756         typename internal::DecayArray<T5>::type,
757         typename internal::DecayArray<T6>::type,
758         typename internal::DecayArray<T7>::type,
759         typename internal::DecayArray<T8>::type,
760         typename internal::DecayArray<T9>::type,
761         typename internal::DecayArray<T10>::type> >
ElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9,const T10 & e10)762 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
763     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
764     const T10& e10) {
765   typedef ::testing::tuple<
766       typename internal::DecayArray<T1>::type,
767       typename internal::DecayArray<T2>::type,
768       typename internal::DecayArray<T3>::type,
769       typename internal::DecayArray<T4>::type,
770       typename internal::DecayArray<T5>::type,
771       typename internal::DecayArray<T6>::type,
772       typename internal::DecayArray<T7>::type,
773       typename internal::DecayArray<T8>::type,
774       typename internal::DecayArray<T9>::type,
775       typename internal::DecayArray<T10>::type> Args;
776   return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
777       e8, e9, e10));
778 }
779 
780 // UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
781 // that matches n elements in any order.  We support up to n=10 arguments.
782 
783 inline internal::UnorderedElementsAreMatcher<
784     ::testing::tuple<> >
UnorderedElementsAre()785 UnorderedElementsAre() {
786   typedef ::testing::tuple<> Args;
787   return internal::UnorderedElementsAreMatcher<Args>(Args());
788 }
789 
790 template <typename T1>
791 inline internal::UnorderedElementsAreMatcher<
792     ::testing::tuple<
793         typename internal::DecayArray<T1>::type> >
UnorderedElementsAre(const T1 & e1)794 UnorderedElementsAre(const T1& e1) {
795   typedef ::testing::tuple<
796       typename internal::DecayArray<T1>::type> Args;
797   return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
798 }
799 
800 template <typename T1, typename T2>
801 inline internal::UnorderedElementsAreMatcher<
802     ::testing::tuple<
803         typename internal::DecayArray<T1>::type,
804         typename internal::DecayArray<T2>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2)805 UnorderedElementsAre(const T1& e1, const T2& e2) {
806   typedef ::testing::tuple<
807       typename internal::DecayArray<T1>::type,
808       typename internal::DecayArray<T2>::type> Args;
809   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
810 }
811 
812 template <typename T1, typename T2, typename T3>
813 inline internal::UnorderedElementsAreMatcher<
814     ::testing::tuple<
815         typename internal::DecayArray<T1>::type,
816         typename internal::DecayArray<T2>::type,
817         typename internal::DecayArray<T3>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3)818 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
819   typedef ::testing::tuple<
820       typename internal::DecayArray<T1>::type,
821       typename internal::DecayArray<T2>::type,
822       typename internal::DecayArray<T3>::type> Args;
823   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
824 }
825 
826 template <typename T1, typename T2, typename T3, typename T4>
827 inline internal::UnorderedElementsAreMatcher<
828     ::testing::tuple<
829         typename internal::DecayArray<T1>::type,
830         typename internal::DecayArray<T2>::type,
831         typename internal::DecayArray<T3>::type,
832         typename internal::DecayArray<T4>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4)833 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
834   typedef ::testing::tuple<
835       typename internal::DecayArray<T1>::type,
836       typename internal::DecayArray<T2>::type,
837       typename internal::DecayArray<T3>::type,
838       typename internal::DecayArray<T4>::type> Args;
839   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
840 }
841 
842 template <typename T1, typename T2, typename T3, typename T4, typename T5>
843 inline internal::UnorderedElementsAreMatcher<
844     ::testing::tuple<
845         typename internal::DecayArray<T1>::type,
846         typename internal::DecayArray<T2>::type,
847         typename internal::DecayArray<T3>::type,
848         typename internal::DecayArray<T4>::type,
849         typename internal::DecayArray<T5>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5)850 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
851     const T5& e5) {
852   typedef ::testing::tuple<
853       typename internal::DecayArray<T1>::type,
854       typename internal::DecayArray<T2>::type,
855       typename internal::DecayArray<T3>::type,
856       typename internal::DecayArray<T4>::type,
857       typename internal::DecayArray<T5>::type> Args;
858   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
859 }
860 
861 template <typename T1, typename T2, typename T3, typename T4, typename T5,
862     typename T6>
863 inline internal::UnorderedElementsAreMatcher<
864     ::testing::tuple<
865         typename internal::DecayArray<T1>::type,
866         typename internal::DecayArray<T2>::type,
867         typename internal::DecayArray<T3>::type,
868         typename internal::DecayArray<T4>::type,
869         typename internal::DecayArray<T5>::type,
870         typename internal::DecayArray<T6>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6)871 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
872     const T5& e5, const T6& e6) {
873   typedef ::testing::tuple<
874       typename internal::DecayArray<T1>::type,
875       typename internal::DecayArray<T2>::type,
876       typename internal::DecayArray<T3>::type,
877       typename internal::DecayArray<T4>::type,
878       typename internal::DecayArray<T5>::type,
879       typename internal::DecayArray<T6>::type> Args;
880   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
881       e6));
882 }
883 
884 template <typename T1, typename T2, typename T3, typename T4, typename T5,
885     typename T6, typename T7>
886 inline internal::UnorderedElementsAreMatcher<
887     ::testing::tuple<
888         typename internal::DecayArray<T1>::type,
889         typename internal::DecayArray<T2>::type,
890         typename internal::DecayArray<T3>::type,
891         typename internal::DecayArray<T4>::type,
892         typename internal::DecayArray<T5>::type,
893         typename internal::DecayArray<T6>::type,
894         typename internal::DecayArray<T7>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7)895 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
896     const T5& e5, const T6& e6, const T7& e7) {
897   typedef ::testing::tuple<
898       typename internal::DecayArray<T1>::type,
899       typename internal::DecayArray<T2>::type,
900       typename internal::DecayArray<T3>::type,
901       typename internal::DecayArray<T4>::type,
902       typename internal::DecayArray<T5>::type,
903       typename internal::DecayArray<T6>::type,
904       typename internal::DecayArray<T7>::type> Args;
905   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
906       e6, e7));
907 }
908 
909 template <typename T1, typename T2, typename T3, typename T4, typename T5,
910     typename T6, typename T7, typename T8>
911 inline internal::UnorderedElementsAreMatcher<
912     ::testing::tuple<
913         typename internal::DecayArray<T1>::type,
914         typename internal::DecayArray<T2>::type,
915         typename internal::DecayArray<T3>::type,
916         typename internal::DecayArray<T4>::type,
917         typename internal::DecayArray<T5>::type,
918         typename internal::DecayArray<T6>::type,
919         typename internal::DecayArray<T7>::type,
920         typename internal::DecayArray<T8>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8)921 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
922     const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
923   typedef ::testing::tuple<
924       typename internal::DecayArray<T1>::type,
925       typename internal::DecayArray<T2>::type,
926       typename internal::DecayArray<T3>::type,
927       typename internal::DecayArray<T4>::type,
928       typename internal::DecayArray<T5>::type,
929       typename internal::DecayArray<T6>::type,
930       typename internal::DecayArray<T7>::type,
931       typename internal::DecayArray<T8>::type> Args;
932   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
933       e6, e7, e8));
934 }
935 
936 template <typename T1, typename T2, typename T3, typename T4, typename T5,
937     typename T6, typename T7, typename T8, typename T9>
938 inline internal::UnorderedElementsAreMatcher<
939     ::testing::tuple<
940         typename internal::DecayArray<T1>::type,
941         typename internal::DecayArray<T2>::type,
942         typename internal::DecayArray<T3>::type,
943         typename internal::DecayArray<T4>::type,
944         typename internal::DecayArray<T5>::type,
945         typename internal::DecayArray<T6>::type,
946         typename internal::DecayArray<T7>::type,
947         typename internal::DecayArray<T8>::type,
948         typename internal::DecayArray<T9>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9)949 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
950     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
951   typedef ::testing::tuple<
952       typename internal::DecayArray<T1>::type,
953       typename internal::DecayArray<T2>::type,
954       typename internal::DecayArray<T3>::type,
955       typename internal::DecayArray<T4>::type,
956       typename internal::DecayArray<T5>::type,
957       typename internal::DecayArray<T6>::type,
958       typename internal::DecayArray<T7>::type,
959       typename internal::DecayArray<T8>::type,
960       typename internal::DecayArray<T9>::type> Args;
961   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
962       e6, e7, e8, e9));
963 }
964 
965 template <typename T1, typename T2, typename T3, typename T4, typename T5,
966     typename T6, typename T7, typename T8, typename T9, typename T10>
967 inline internal::UnorderedElementsAreMatcher<
968     ::testing::tuple<
969         typename internal::DecayArray<T1>::type,
970         typename internal::DecayArray<T2>::type,
971         typename internal::DecayArray<T3>::type,
972         typename internal::DecayArray<T4>::type,
973         typename internal::DecayArray<T5>::type,
974         typename internal::DecayArray<T6>::type,
975         typename internal::DecayArray<T7>::type,
976         typename internal::DecayArray<T8>::type,
977         typename internal::DecayArray<T9>::type,
978         typename internal::DecayArray<T10>::type> >
UnorderedElementsAre(const T1 & e1,const T2 & e2,const T3 & e3,const T4 & e4,const T5 & e5,const T6 & e6,const T7 & e7,const T8 & e8,const T9 & e9,const T10 & e10)979 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
980     const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
981     const T10& e10) {
982   typedef ::testing::tuple<
983       typename internal::DecayArray<T1>::type,
984       typename internal::DecayArray<T2>::type,
985       typename internal::DecayArray<T3>::type,
986       typename internal::DecayArray<T4>::type,
987       typename internal::DecayArray<T5>::type,
988       typename internal::DecayArray<T6>::type,
989       typename internal::DecayArray<T7>::type,
990       typename internal::DecayArray<T8>::type,
991       typename internal::DecayArray<T9>::type,
992       typename internal::DecayArray<T10>::type> Args;
993   return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
994       e6, e7, e8, e9, e10));
995 }
996 
997 // AllOf(m1, m2, ..., mk) matches any value that matches all of the given
998 // sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
999 
1000 template <typename M1, typename M2>
1001 inline typename internal::AllOfResult2<M1, M2>::type
AllOf(M1 m1,M2 m2)1002 AllOf(M1 m1, M2 m2) {
1003   return typename internal::AllOfResult2<M1, M2>::type(
1004       m1,
1005       m2);
1006 }
1007 
1008 template <typename M1, typename M2, typename M3>
1009 inline typename internal::AllOfResult3<M1, M2, M3>::type
AllOf(M1 m1,M2 m2,M3 m3)1010 AllOf(M1 m1, M2 m2, M3 m3) {
1011   return typename internal::AllOfResult3<M1, M2, M3>::type(
1012       m1,
1013       ::testing::AllOf(m2, m3));
1014 }
1015 
1016 template <typename M1, typename M2, typename M3, typename M4>
1017 inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4)1018 AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
1019   return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
1020       ::testing::AllOf(m1, m2),
1021       ::testing::AllOf(m3, m4));
1022 }
1023 
1024 template <typename M1, typename M2, typename M3, typename M4, typename M5>
1025 inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5)1026 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
1027   return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
1028       ::testing::AllOf(m1, m2),
1029       ::testing::AllOf(m3, m4, m5));
1030 }
1031 
1032 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1033     typename M6>
1034 inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6)1035 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
1036   return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
1037       ::testing::AllOf(m1, m2, m3),
1038       ::testing::AllOf(m4, m5, m6));
1039 }
1040 
1041 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1042     typename M6, typename M7>
1043 inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7)1044 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
1045   return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1046       ::testing::AllOf(m1, m2, m3),
1047       ::testing::AllOf(m4, m5, m6, m7));
1048 }
1049 
1050 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1051     typename M6, typename M7, typename M8>
1052 inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8)1053 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
1054   return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1055       ::testing::AllOf(m1, m2, m3, m4),
1056       ::testing::AllOf(m5, m6, m7, m8));
1057 }
1058 
1059 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1060     typename M6, typename M7, typename M8, typename M9>
1061 inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9)1062 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
1063   return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1064       M9>::type(
1065       ::testing::AllOf(m1, m2, m3, m4),
1066       ::testing::AllOf(m5, m6, m7, m8, m9));
1067 }
1068 
1069 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1070     typename M6, typename M7, typename M8, typename M9, typename M10>
1071 inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1072     M10>::type
AllOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9,M10 m10)1073 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
1074   return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1075       M10>::type(
1076       ::testing::AllOf(m1, m2, m3, m4, m5),
1077       ::testing::AllOf(m6, m7, m8, m9, m10));
1078 }
1079 
1080 // AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
1081 // sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
1082 
1083 template <typename M1, typename M2>
1084 inline typename internal::AnyOfResult2<M1, M2>::type
AnyOf(M1 m1,M2 m2)1085 AnyOf(M1 m1, M2 m2) {
1086   return typename internal::AnyOfResult2<M1, M2>::type(
1087       m1,
1088       m2);
1089 }
1090 
1091 template <typename M1, typename M2, typename M3>
1092 inline typename internal::AnyOfResult3<M1, M2, M3>::type
AnyOf(M1 m1,M2 m2,M3 m3)1093 AnyOf(M1 m1, M2 m2, M3 m3) {
1094   return typename internal::AnyOfResult3<M1, M2, M3>::type(
1095       m1,
1096       ::testing::AnyOf(m2, m3));
1097 }
1098 
1099 template <typename M1, typename M2, typename M3, typename M4>
1100 inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4)1101 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
1102   return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
1103       ::testing::AnyOf(m1, m2),
1104       ::testing::AnyOf(m3, m4));
1105 }
1106 
1107 template <typename M1, typename M2, typename M3, typename M4, typename M5>
1108 inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5)1109 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
1110   return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
1111       ::testing::AnyOf(m1, m2),
1112       ::testing::AnyOf(m3, m4, m5));
1113 }
1114 
1115 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1116     typename M6>
1117 inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6)1118 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
1119   return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
1120       ::testing::AnyOf(m1, m2, m3),
1121       ::testing::AnyOf(m4, m5, m6));
1122 }
1123 
1124 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1125     typename M6, typename M7>
1126 inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7)1127 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
1128   return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
1129       ::testing::AnyOf(m1, m2, m3),
1130       ::testing::AnyOf(m4, m5, m6, m7));
1131 }
1132 
1133 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1134     typename M6, typename M7, typename M8>
1135 inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8)1136 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
1137   return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
1138       ::testing::AnyOf(m1, m2, m3, m4),
1139       ::testing::AnyOf(m5, m6, m7, m8));
1140 }
1141 
1142 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1143     typename M6, typename M7, typename M8, typename M9>
1144 inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9)1145 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
1146   return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
1147       M9>::type(
1148       ::testing::AnyOf(m1, m2, m3, m4),
1149       ::testing::AnyOf(m5, m6, m7, m8, m9));
1150 }
1151 
1152 template <typename M1, typename M2, typename M3, typename M4, typename M5,
1153     typename M6, typename M7, typename M8, typename M9, typename M10>
1154 inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1155     M10>::type
AnyOf(M1 m1,M2 m2,M3 m3,M4 m4,M5 m5,M6 m6,M7 m7,M8 m8,M9 m9,M10 m10)1156 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
1157   return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
1158       M10>::type(
1159       ::testing::AnyOf(m1, m2, m3, m4, m5),
1160       ::testing::AnyOf(m6, m7, m8, m9, m10));
1161 }
1162 
1163 }  // namespace testing
1164 
1165 
1166 // The MATCHER* family of macros can be used in a namespace scope to
1167 // define custom matchers easily.
1168 //
1169 // Basic Usage
1170 // ===========
1171 //
1172 // The syntax
1173 //
1174 //   MATCHER(name, description_string) { statements; }
1175 //
1176 // defines a matcher with the given name that executes the statements,
1177 // which must return a bool to indicate if the match succeeds.  Inside
1178 // the statements, you can refer to the value being matched by 'arg',
1179 // and refer to its type by 'arg_type'.
1180 //
1181 // The description string documents what the matcher does, and is used
1182 // to generate the failure message when the match fails.  Since a
1183 // MATCHER() is usually defined in a header file shared by multiple
1184 // C++ source files, we require the description to be a C-string
1185 // literal to avoid possible side effects.  It can be empty, in which
1186 // case we'll use the sequence of words in the matcher name as the
1187 // description.
1188 //
1189 // For example:
1190 //
1191 //   MATCHER(IsEven, "") { return (arg % 2) == 0; }
1192 //
1193 // allows you to write
1194 //
1195 //   // Expects mock_foo.Bar(n) to be called where n is even.
1196 //   EXPECT_CALL(mock_foo, Bar(IsEven()));
1197 //
1198 // or,
1199 //
1200 //   // Verifies that the value of some_expression is even.
1201 //   EXPECT_THAT(some_expression, IsEven());
1202 //
1203 // If the above assertion fails, it will print something like:
1204 //
1205 //   Value of: some_expression
1206 //   Expected: is even
1207 //     Actual: 7
1208 //
1209 // where the description "is even" is automatically calculated from the
1210 // matcher name IsEven.
1211 //
1212 // Argument Type
1213 // =============
1214 //
1215 // Note that the type of the value being matched (arg_type) is
1216 // determined by the context in which you use the matcher and is
1217 // supplied to you by the compiler, so you don't need to worry about
1218 // declaring it (nor can you).  This allows the matcher to be
1219 // polymorphic.  For example, IsEven() can be used to match any type
1220 // where the value of "(arg % 2) == 0" can be implicitly converted to
1221 // a bool.  In the "Bar(IsEven())" example above, if method Bar()
1222 // takes an int, 'arg_type' will be int; if it takes an unsigned long,
1223 // 'arg_type' will be unsigned long; and so on.
1224 //
1225 // Parameterizing Matchers
1226 // =======================
1227 //
1228 // Sometimes you'll want to parameterize the matcher.  For that you
1229 // can use another macro:
1230 //
1231 //   MATCHER_P(name, param_name, description_string) { statements; }
1232 //
1233 // For example:
1234 //
1235 //   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
1236 //
1237 // will allow you to write:
1238 //
1239 //   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
1240 //
1241 // which may lead to this message (assuming n is 10):
1242 //
1243 //   Value of: Blah("a")
1244 //   Expected: has absolute value 10
1245 //     Actual: -9
1246 //
1247 // Note that both the matcher description and its parameter are
1248 // printed, making the message human-friendly.
1249 //
1250 // In the matcher definition body, you can write 'foo_type' to
1251 // reference the type of a parameter named 'foo'.  For example, in the
1252 // body of MATCHER_P(HasAbsoluteValue, value) above, you can write
1253 // 'value_type' to refer to the type of 'value'.
1254 //
1255 // We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
1256 // support multi-parameter matchers.
1257 //
1258 // Describing Parameterized Matchers
1259 // =================================
1260 //
1261 // The last argument to MATCHER*() is a string-typed expression.  The
1262 // expression can reference all of the matcher's parameters and a
1263 // special bool-typed variable named 'negation'.  When 'negation' is
1264 // false, the expression should evaluate to the matcher's description;
1265 // otherwise it should evaluate to the description of the negation of
1266 // the matcher.  For example,
1267 //
1268 //   using testing::PrintToString;
1269 //
1270 //   MATCHER_P2(InClosedRange, low, hi,
1271 //       string(negation ? "is not" : "is") + " in range [" +
1272 //       PrintToString(low) + ", " + PrintToString(hi) + "]") {
1273 //     return low <= arg && arg <= hi;
1274 //   }
1275 //   ...
1276 //   EXPECT_THAT(3, InClosedRange(4, 6));
1277 //   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1278 //
1279 // would generate two failures that contain the text:
1280 //
1281 //   Expected: is in range [4, 6]
1282 //   ...
1283 //   Expected: is not in range [2, 4]
1284 //
1285 // If you specify "" as the description, the failure message will
1286 // contain the sequence of words in the matcher name followed by the
1287 // parameter values printed as a tuple.  For example,
1288 //
1289 //   MATCHER_P2(InClosedRange, low, hi, "") { ... }
1290 //   ...
1291 //   EXPECT_THAT(3, InClosedRange(4, 6));
1292 //   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
1293 //
1294 // would generate two failures that contain the text:
1295 //
1296 //   Expected: in closed range (4, 6)
1297 //   ...
1298 //   Expected: not (in closed range (2, 4))
1299 //
1300 // Types of Matcher Parameters
1301 // ===========================
1302 //
1303 // For the purpose of typing, you can view
1304 //
1305 //   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
1306 //
1307 // as shorthand for
1308 //
1309 //   template <typename p1_type, ..., typename pk_type>
1310 //   FooMatcherPk<p1_type, ..., pk_type>
1311 //   Foo(p1_type p1, ..., pk_type pk) { ... }
1312 //
1313 // When you write Foo(v1, ..., vk), the compiler infers the types of
1314 // the parameters v1, ..., and vk for you.  If you are not happy with
1315 // the result of the type inference, you can specify the types by
1316 // explicitly instantiating the template, as in Foo<long, bool>(5,
1317 // false).  As said earlier, you don't get to (or need to) specify
1318 // 'arg_type' as that's determined by the context in which the matcher
1319 // is used.  You can assign the result of expression Foo(p1, ..., pk)
1320 // to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
1321 // can be useful when composing matchers.
1322 //
1323 // While you can instantiate a matcher template with reference types,
1324 // passing the parameters by pointer usually makes your code more
1325 // readable.  If, however, you still want to pass a parameter by
1326 // reference, be aware that in the failure message generated by the
1327 // matcher you will see the value of the referenced object but not its
1328 // address.
1329 //
1330 // Explaining Match Results
1331 // ========================
1332 //
1333 // Sometimes the matcher description alone isn't enough to explain why
1334 // the match has failed or succeeded.  For example, when expecting a
1335 // long string, it can be very helpful to also print the diff between
1336 // the expected string and the actual one.  To achieve that, you can
1337 // optionally stream additional information to a special variable
1338 // named result_listener, whose type is a pointer to class
1339 // MatchResultListener:
1340 //
1341 //   MATCHER_P(EqualsLongString, str, "") {
1342 //     if (arg == str) return true;
1343 //
1344 //     *result_listener << "the difference: "
1345 ///                     << DiffStrings(str, arg);
1346 //     return false;
1347 //   }
1348 //
1349 // Overloading Matchers
1350 // ====================
1351 //
1352 // You can overload matchers with different numbers of parameters:
1353 //
1354 //   MATCHER_P(Blah, a, description_string1) { ... }
1355 //   MATCHER_P2(Blah, a, b, description_string2) { ... }
1356 //
1357 // Caveats
1358 // =======
1359 //
1360 // When defining a new matcher, you should also consider implementing
1361 // MatcherInterface or using MakePolymorphicMatcher().  These
1362 // approaches require more work than the MATCHER* macros, but also
1363 // give you more control on the types of the value being matched and
1364 // the matcher parameters, which may leads to better compiler error
1365 // messages when the matcher is used wrong.  They also allow
1366 // overloading matchers based on parameter types (as opposed to just
1367 // based on the number of parameters).
1368 //
1369 // MATCHER*() can only be used in a namespace scope.  The reason is
1370 // that C++ doesn't yet allow function-local types to be used to
1371 // instantiate templates.  The up-coming C++0x standard will fix this.
1372 // Once that's done, we'll consider supporting using MATCHER*() inside
1373 // a function.
1374 //
1375 // More Information
1376 // ================
1377 //
1378 // To learn more about using these macros, please search for 'MATCHER'
1379 // on http://code.google.com/p/googlemock/wiki/CookBook.
1380 
1381 #define MATCHER(name, description)\
1382   class name##Matcher {\
1383    public:\
1384     template <typename arg_type>\
1385     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1386      public:\
1387       gmock_Impl()\
1388            {}\
1389       virtual bool MatchAndExplain(\
1390           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1391       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1392         *gmock_os << FormatDescription(false);\
1393       }\
1394       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1395         *gmock_os << FormatDescription(true);\
1396       }\
1397      private:\
1398       ::testing::internal::string FormatDescription(bool negation) const {\
1399         const ::testing::internal::string gmock_description = (description);\
1400         if (!gmock_description.empty())\
1401           return gmock_description;\
1402         return ::testing::internal::FormatMatcherDescription(\
1403             negation, #name, \
1404             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1405                 ::testing::tuple<>()));\
1406       }\
1407       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1408     };\
1409     template <typename arg_type>\
1410     operator ::testing::Matcher<arg_type>() const {\
1411       return ::testing::Matcher<arg_type>(\
1412           new gmock_Impl<arg_type>());\
1413     }\
1414     name##Matcher() {\
1415     }\
1416    private:\
1417     GTEST_DISALLOW_ASSIGN_(name##Matcher);\
1418   };\
1419   inline name##Matcher name() {\
1420     return name##Matcher();\
1421   }\
1422   template <typename arg_type>\
1423   bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
1424       arg_type arg, \
1425       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1426           const
1427 
1428 #define MATCHER_P(name, p0, description)\
1429   template <typename p0##_type>\
1430   class name##MatcherP {\
1431    public:\
1432     template <typename arg_type>\
1433     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1434      public:\
1435       explicit gmock_Impl(p0##_type gmock_p0)\
1436            : p0(gmock_p0) {}\
1437       virtual bool MatchAndExplain(\
1438           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1439       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1440         *gmock_os << FormatDescription(false);\
1441       }\
1442       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1443         *gmock_os << FormatDescription(true);\
1444       }\
1445       p0##_type p0;\
1446      private:\
1447       ::testing::internal::string FormatDescription(bool negation) const {\
1448         const ::testing::internal::string gmock_description = (description);\
1449         if (!gmock_description.empty())\
1450           return gmock_description;\
1451         return ::testing::internal::FormatMatcherDescription(\
1452             negation, #name, \
1453             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1454                 ::testing::tuple<p0##_type>(p0)));\
1455       }\
1456       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1457     };\
1458     template <typename arg_type>\
1459     operator ::testing::Matcher<arg_type>() const {\
1460       return ::testing::Matcher<arg_type>(\
1461           new gmock_Impl<arg_type>(p0));\
1462     }\
1463     explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
1464     }\
1465     p0##_type p0;\
1466    private:\
1467     GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
1468   };\
1469   template <typename p0##_type>\
1470   inline name##MatcherP<p0##_type> name(p0##_type p0) {\
1471     return name##MatcherP<p0##_type>(p0);\
1472   }\
1473   template <typename p0##_type>\
1474   template <typename arg_type>\
1475   bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1476       arg_type arg, \
1477       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1478           const
1479 
1480 #define MATCHER_P2(name, p0, p1, description)\
1481   template <typename p0##_type, typename p1##_type>\
1482   class name##MatcherP2 {\
1483    public:\
1484     template <typename arg_type>\
1485     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1486      public:\
1487       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
1488            : p0(gmock_p0), p1(gmock_p1) {}\
1489       virtual bool MatchAndExplain(\
1490           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1491       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1492         *gmock_os << FormatDescription(false);\
1493       }\
1494       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1495         *gmock_os << FormatDescription(true);\
1496       }\
1497       p0##_type p0;\
1498       p1##_type p1;\
1499      private:\
1500       ::testing::internal::string FormatDescription(bool negation) const {\
1501         const ::testing::internal::string gmock_description = (description);\
1502         if (!gmock_description.empty())\
1503           return gmock_description;\
1504         return ::testing::internal::FormatMatcherDescription(\
1505             negation, #name, \
1506             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1507                 ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
1508       }\
1509       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1510     };\
1511     template <typename arg_type>\
1512     operator ::testing::Matcher<arg_type>() const {\
1513       return ::testing::Matcher<arg_type>(\
1514           new gmock_Impl<arg_type>(p0, p1));\
1515     }\
1516     name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1517         p1(gmock_p1) {\
1518     }\
1519     p0##_type p0;\
1520     p1##_type p1;\
1521    private:\
1522     GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
1523   };\
1524   template <typename p0##_type, typename p1##_type>\
1525   inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
1526       p1##_type p1) {\
1527     return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
1528   }\
1529   template <typename p0##_type, typename p1##_type>\
1530   template <typename arg_type>\
1531   bool name##MatcherP2<p0##_type, \
1532       p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1533       arg_type arg, \
1534       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1535           const
1536 
1537 #define MATCHER_P3(name, p0, p1, p2, description)\
1538   template <typename p0##_type, typename p1##_type, typename p2##_type>\
1539   class name##MatcherP3 {\
1540    public:\
1541     template <typename arg_type>\
1542     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1543      public:\
1544       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
1545            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1546       virtual bool MatchAndExplain(\
1547           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1548       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1549         *gmock_os << FormatDescription(false);\
1550       }\
1551       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1552         *gmock_os << FormatDescription(true);\
1553       }\
1554       p0##_type p0;\
1555       p1##_type p1;\
1556       p2##_type p2;\
1557      private:\
1558       ::testing::internal::string FormatDescription(bool negation) const {\
1559         const ::testing::internal::string gmock_description = (description);\
1560         if (!gmock_description.empty())\
1561           return gmock_description;\
1562         return ::testing::internal::FormatMatcherDescription(\
1563             negation, #name, \
1564             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1565                 ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
1566                     p2)));\
1567       }\
1568       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1569     };\
1570     template <typename arg_type>\
1571     operator ::testing::Matcher<arg_type>() const {\
1572       return ::testing::Matcher<arg_type>(\
1573           new gmock_Impl<arg_type>(p0, p1, p2));\
1574     }\
1575     name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
1576         p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
1577     }\
1578     p0##_type p0;\
1579     p1##_type p1;\
1580     p2##_type p2;\
1581    private:\
1582     GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
1583   };\
1584   template <typename p0##_type, typename p1##_type, typename p2##_type>\
1585   inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
1586       p1##_type p1, p2##_type p2) {\
1587     return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
1588   }\
1589   template <typename p0##_type, typename p1##_type, typename p2##_type>\
1590   template <typename arg_type>\
1591   bool name##MatcherP3<p0##_type, p1##_type, \
1592       p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1593       arg_type arg, \
1594       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1595           const
1596 
1597 #define MATCHER_P4(name, p0, p1, p2, p3, description)\
1598   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1599       typename p3##_type>\
1600   class name##MatcherP4 {\
1601    public:\
1602     template <typename arg_type>\
1603     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1604      public:\
1605       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1606           p3##_type gmock_p3)\
1607            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
1608       virtual bool MatchAndExplain(\
1609           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1610       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1611         *gmock_os << FormatDescription(false);\
1612       }\
1613       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1614         *gmock_os << FormatDescription(true);\
1615       }\
1616       p0##_type p0;\
1617       p1##_type p1;\
1618       p2##_type p2;\
1619       p3##_type p3;\
1620      private:\
1621       ::testing::internal::string FormatDescription(bool negation) const {\
1622         const ::testing::internal::string gmock_description = (description);\
1623         if (!gmock_description.empty())\
1624           return gmock_description;\
1625         return ::testing::internal::FormatMatcherDescription(\
1626             negation, #name, \
1627             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1628                 ::testing::tuple<p0##_type, p1##_type, p2##_type, \
1629                     p3##_type>(p0, p1, p2, p3)));\
1630       }\
1631       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1632     };\
1633     template <typename arg_type>\
1634     operator ::testing::Matcher<arg_type>() const {\
1635       return ::testing::Matcher<arg_type>(\
1636           new gmock_Impl<arg_type>(p0, p1, p2, p3));\
1637     }\
1638     name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
1639         p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
1640         p2(gmock_p2), p3(gmock_p3) {\
1641     }\
1642     p0##_type p0;\
1643     p1##_type p1;\
1644     p2##_type p2;\
1645     p3##_type p3;\
1646    private:\
1647     GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
1648   };\
1649   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1650       typename p3##_type>\
1651   inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
1652       p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1653       p3##_type p3) {\
1654     return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
1655         p1, p2, p3);\
1656   }\
1657   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1658       typename p3##_type>\
1659   template <typename arg_type>\
1660   bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
1661       p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1662       arg_type arg, \
1663       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1664           const
1665 
1666 #define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
1667   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1668       typename p3##_type, typename p4##_type>\
1669   class name##MatcherP5 {\
1670    public:\
1671     template <typename arg_type>\
1672     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1673      public:\
1674       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1675           p3##_type gmock_p3, p4##_type gmock_p4)\
1676            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1677                p4(gmock_p4) {}\
1678       virtual bool MatchAndExplain(\
1679           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1680       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1681         *gmock_os << FormatDescription(false);\
1682       }\
1683       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1684         *gmock_os << FormatDescription(true);\
1685       }\
1686       p0##_type p0;\
1687       p1##_type p1;\
1688       p2##_type p2;\
1689       p3##_type p3;\
1690       p4##_type p4;\
1691      private:\
1692       ::testing::internal::string FormatDescription(bool negation) const {\
1693         const ::testing::internal::string gmock_description = (description);\
1694         if (!gmock_description.empty())\
1695           return gmock_description;\
1696         return ::testing::internal::FormatMatcherDescription(\
1697             negation, #name, \
1698             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1699                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1700                     p4##_type>(p0, p1, p2, p3, p4)));\
1701       }\
1702       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1703     };\
1704     template <typename arg_type>\
1705     operator ::testing::Matcher<arg_type>() const {\
1706       return ::testing::Matcher<arg_type>(\
1707           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
1708     }\
1709     name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
1710         p2##_type gmock_p2, p3##_type gmock_p3, \
1711         p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1712         p3(gmock_p3), p4(gmock_p4) {\
1713     }\
1714     p0##_type p0;\
1715     p1##_type p1;\
1716     p2##_type p2;\
1717     p3##_type p3;\
1718     p4##_type p4;\
1719    private:\
1720     GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
1721   };\
1722   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1723       typename p3##_type, typename p4##_type>\
1724   inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1725       p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1726       p4##_type p4) {\
1727     return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1728         p4##_type>(p0, p1, p2, p3, p4);\
1729   }\
1730   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1731       typename p3##_type, typename p4##_type>\
1732   template <typename arg_type>\
1733   bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1734       p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1735       arg_type arg, \
1736       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1737           const
1738 
1739 #define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
1740   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1741       typename p3##_type, typename p4##_type, typename p5##_type>\
1742   class name##MatcherP6 {\
1743    public:\
1744     template <typename arg_type>\
1745     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1746      public:\
1747       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1748           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
1749            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1750                p4(gmock_p4), p5(gmock_p5) {}\
1751       virtual bool MatchAndExplain(\
1752           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1753       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1754         *gmock_os << FormatDescription(false);\
1755       }\
1756       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1757         *gmock_os << FormatDescription(true);\
1758       }\
1759       p0##_type p0;\
1760       p1##_type p1;\
1761       p2##_type p2;\
1762       p3##_type p3;\
1763       p4##_type p4;\
1764       p5##_type p5;\
1765      private:\
1766       ::testing::internal::string FormatDescription(bool negation) const {\
1767         const ::testing::internal::string gmock_description = (description);\
1768         if (!gmock_description.empty())\
1769           return gmock_description;\
1770         return ::testing::internal::FormatMatcherDescription(\
1771             negation, #name, \
1772             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1773                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1774                     p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
1775       }\
1776       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1777     };\
1778     template <typename arg_type>\
1779     operator ::testing::Matcher<arg_type>() const {\
1780       return ::testing::Matcher<arg_type>(\
1781           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
1782     }\
1783     name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
1784         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1785         p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1786         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
1787     }\
1788     p0##_type p0;\
1789     p1##_type p1;\
1790     p2##_type p2;\
1791     p3##_type p3;\
1792     p4##_type p4;\
1793     p5##_type p5;\
1794    private:\
1795     GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
1796   };\
1797   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1798       typename p3##_type, typename p4##_type, typename p5##_type>\
1799   inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1800       p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1801       p3##_type p3, p4##_type p4, p5##_type p5) {\
1802     return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1803         p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
1804   }\
1805   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1806       typename p3##_type, typename p4##_type, typename p5##_type>\
1807   template <typename arg_type>\
1808   bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1809       p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1810       arg_type arg, \
1811       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1812           const
1813 
1814 #define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
1815   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1816       typename p3##_type, typename p4##_type, typename p5##_type, \
1817       typename p6##_type>\
1818   class name##MatcherP7 {\
1819    public:\
1820     template <typename arg_type>\
1821     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1822      public:\
1823       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1824           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1825           p6##_type gmock_p6)\
1826            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1827                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
1828       virtual bool MatchAndExplain(\
1829           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1830       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1831         *gmock_os << FormatDescription(false);\
1832       }\
1833       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1834         *gmock_os << FormatDescription(true);\
1835       }\
1836       p0##_type p0;\
1837       p1##_type p1;\
1838       p2##_type p2;\
1839       p3##_type p3;\
1840       p4##_type p4;\
1841       p5##_type p5;\
1842       p6##_type p6;\
1843      private:\
1844       ::testing::internal::string FormatDescription(bool negation) const {\
1845         const ::testing::internal::string gmock_description = (description);\
1846         if (!gmock_description.empty())\
1847           return gmock_description;\
1848         return ::testing::internal::FormatMatcherDescription(\
1849             negation, #name, \
1850             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1851                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1852                     p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
1853                     p6)));\
1854       }\
1855       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1856     };\
1857     template <typename arg_type>\
1858     operator ::testing::Matcher<arg_type>() const {\
1859       return ::testing::Matcher<arg_type>(\
1860           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
1861     }\
1862     name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
1863         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1864         p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
1865         p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
1866         p6(gmock_p6) {\
1867     }\
1868     p0##_type p0;\
1869     p1##_type p1;\
1870     p2##_type p2;\
1871     p3##_type p3;\
1872     p4##_type p4;\
1873     p5##_type p5;\
1874     p6##_type p6;\
1875    private:\
1876     GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
1877   };\
1878   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1879       typename p3##_type, typename p4##_type, typename p5##_type, \
1880       typename p6##_type>\
1881   inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1882       p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
1883       p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1884       p6##_type p6) {\
1885     return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1886         p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
1887   }\
1888   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1889       typename p3##_type, typename p4##_type, typename p5##_type, \
1890       typename p6##_type>\
1891   template <typename arg_type>\
1892   bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1893       p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1894       arg_type arg, \
1895       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1896           const
1897 
1898 #define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
1899   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1900       typename p3##_type, typename p4##_type, typename p5##_type, \
1901       typename p6##_type, typename p7##_type>\
1902   class name##MatcherP8 {\
1903    public:\
1904     template <typename arg_type>\
1905     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1906      public:\
1907       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1908           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1909           p6##_type gmock_p6, p7##_type gmock_p7)\
1910            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
1911                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
1912       virtual bool MatchAndExplain(\
1913           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
1914       virtual void DescribeTo(::std::ostream* gmock_os) const {\
1915         *gmock_os << FormatDescription(false);\
1916       }\
1917       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1918         *gmock_os << FormatDescription(true);\
1919       }\
1920       p0##_type p0;\
1921       p1##_type p1;\
1922       p2##_type p2;\
1923       p3##_type p3;\
1924       p4##_type p4;\
1925       p5##_type p5;\
1926       p6##_type p6;\
1927       p7##_type p7;\
1928      private:\
1929       ::testing::internal::string FormatDescription(bool negation) const {\
1930         const ::testing::internal::string gmock_description = (description);\
1931         if (!gmock_description.empty())\
1932           return gmock_description;\
1933         return ::testing::internal::FormatMatcherDescription(\
1934             negation, #name, \
1935             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1936                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1937                     p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
1938                     p3, p4, p5, p6, p7)));\
1939       }\
1940       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1941     };\
1942     template <typename arg_type>\
1943     operator ::testing::Matcher<arg_type>() const {\
1944       return ::testing::Matcher<arg_type>(\
1945           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
1946     }\
1947     name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
1948         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1949         p5##_type gmock_p5, p6##_type gmock_p6, \
1950         p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1951         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1952         p7(gmock_p7) {\
1953     }\
1954     p0##_type p0;\
1955     p1##_type p1;\
1956     p2##_type p2;\
1957     p3##_type p3;\
1958     p4##_type p4;\
1959     p5##_type p5;\
1960     p6##_type p6;\
1961     p7##_type p7;\
1962    private:\
1963     GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
1964   };\
1965   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1966       typename p3##_type, typename p4##_type, typename p5##_type, \
1967       typename p6##_type, typename p7##_type>\
1968   inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1969       p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
1970       p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1971       p6##_type p6, p7##_type p7) {\
1972     return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1973         p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
1974         p6, p7);\
1975   }\
1976   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1977       typename p3##_type, typename p4##_type, typename p5##_type, \
1978       typename p6##_type, typename p7##_type>\
1979   template <typename arg_type>\
1980   bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1981       p5##_type, p6##_type, \
1982       p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1983       arg_type arg, \
1984       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1985           const
1986 
1987 #define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
1988   template <typename p0##_type, typename p1##_type, typename p2##_type, \
1989       typename p3##_type, typename p4##_type, typename p5##_type, \
1990       typename p6##_type, typename p7##_type, typename p8##_type>\
1991   class name##MatcherP9 {\
1992    public:\
1993     template <typename arg_type>\
1994     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
1995      public:\
1996       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1997           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1998           p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
1999            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
2000                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
2001                p8(gmock_p8) {}\
2002       virtual bool MatchAndExplain(\
2003           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
2004       virtual void DescribeTo(::std::ostream* gmock_os) const {\
2005         *gmock_os << FormatDescription(false);\
2006       }\
2007       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
2008         *gmock_os << FormatDescription(true);\
2009       }\
2010       p0##_type p0;\
2011       p1##_type p1;\
2012       p2##_type p2;\
2013       p3##_type p3;\
2014       p4##_type p4;\
2015       p5##_type p5;\
2016       p6##_type p6;\
2017       p7##_type p7;\
2018       p8##_type p8;\
2019      private:\
2020       ::testing::internal::string FormatDescription(bool negation) const {\
2021         const ::testing::internal::string gmock_description = (description);\
2022         if (!gmock_description.empty())\
2023           return gmock_description;\
2024         return ::testing::internal::FormatMatcherDescription(\
2025             negation, #name, \
2026             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
2027                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
2028                     p4##_type, p5##_type, p6##_type, p7##_type, \
2029                     p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
2030       }\
2031       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2032     };\
2033     template <typename arg_type>\
2034     operator ::testing::Matcher<arg_type>() const {\
2035       return ::testing::Matcher<arg_type>(\
2036           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
2037     }\
2038     name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
2039         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
2040         p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
2041         p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
2042         p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
2043         p8(gmock_p8) {\
2044     }\
2045     p0##_type p0;\
2046     p1##_type p1;\
2047     p2##_type p2;\
2048     p3##_type p3;\
2049     p4##_type p4;\
2050     p5##_type p5;\
2051     p6##_type p6;\
2052     p7##_type p7;\
2053     p8##_type p8;\
2054    private:\
2055     GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
2056   };\
2057   template <typename p0##_type, typename p1##_type, typename p2##_type, \
2058       typename p3##_type, typename p4##_type, typename p5##_type, \
2059       typename p6##_type, typename p7##_type, typename p8##_type>\
2060   inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
2061       p4##_type, p5##_type, p6##_type, p7##_type, \
2062       p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2063       p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
2064       p8##_type p8) {\
2065     return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
2066         p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
2067         p3, p4, p5, p6, p7, p8);\
2068   }\
2069   template <typename p0##_type, typename p1##_type, typename p2##_type, \
2070       typename p3##_type, typename p4##_type, typename p5##_type, \
2071       typename p6##_type, typename p7##_type, typename p8##_type>\
2072   template <typename arg_type>\
2073   bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2074       p5##_type, p6##_type, p7##_type, \
2075       p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2076       arg_type arg, \
2077       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2078           const
2079 
2080 #define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
2081   template <typename p0##_type, typename p1##_type, typename p2##_type, \
2082       typename p3##_type, typename p4##_type, typename p5##_type, \
2083       typename p6##_type, typename p7##_type, typename p8##_type, \
2084       typename p9##_type>\
2085   class name##MatcherP10 {\
2086    public:\
2087     template <typename arg_type>\
2088     class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
2089      public:\
2090       gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2091           p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2092           p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
2093           p9##_type gmock_p9)\
2094            : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
2095                p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
2096                p8(gmock_p8), p9(gmock_p9) {}\
2097       virtual bool MatchAndExplain(\
2098           arg_type arg, ::testing::MatchResultListener* result_listener) const;\
2099       virtual void DescribeTo(::std::ostream* gmock_os) const {\
2100         *gmock_os << FormatDescription(false);\
2101       }\
2102       virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
2103         *gmock_os << FormatDescription(true);\
2104       }\
2105       p0##_type p0;\
2106       p1##_type p1;\
2107       p2##_type p2;\
2108       p3##_type p3;\
2109       p4##_type p4;\
2110       p5##_type p5;\
2111       p6##_type p6;\
2112       p7##_type p7;\
2113       p8##_type p8;\
2114       p9##_type p9;\
2115      private:\
2116       ::testing::internal::string FormatDescription(bool negation) const {\
2117         const ::testing::internal::string gmock_description = (description);\
2118         if (!gmock_description.empty())\
2119           return gmock_description;\
2120         return ::testing::internal::FormatMatcherDescription(\
2121             negation, #name, \
2122             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
2123                 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
2124                     p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2125                     p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
2126       }\
2127       GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2128     };\
2129     template <typename arg_type>\
2130     operator ::testing::Matcher<arg_type>() const {\
2131       return ::testing::Matcher<arg_type>(\
2132           new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
2133     }\
2134     name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
2135         p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
2136         p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
2137         p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
2138         p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
2139         p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\
2140     }\
2141     p0##_type p0;\
2142     p1##_type p1;\
2143     p2##_type p2;\
2144     p3##_type p3;\
2145     p4##_type p4;\
2146     p5##_type p5;\
2147     p6##_type p6;\
2148     p7##_type p7;\
2149     p8##_type p8;\
2150     p9##_type p9;\
2151    private:\
2152     GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
2153   };\
2154   template <typename p0##_type, typename p1##_type, typename p2##_type, \
2155       typename p3##_type, typename p4##_type, typename p5##_type, \
2156       typename p6##_type, typename p7##_type, typename p8##_type, \
2157       typename p9##_type>\
2158   inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2159       p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2160       p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2161       p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
2162       p9##_type p9) {\
2163     return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2164         p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
2165         p1, p2, p3, p4, p5, p6, p7, p8, p9);\
2166   }\
2167   template <typename p0##_type, typename p1##_type, typename p2##_type, \
2168       typename p3##_type, typename p4##_type, typename p5##_type, \
2169       typename p6##_type, typename p7##_type, typename p8##_type, \
2170       typename p9##_type>\
2171   template <typename arg_type>\
2172   bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2173       p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2174       p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
2175       arg_type arg, \
2176       ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
2177           const
2178 
2179 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
2180