Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gmock-generated-matchers.h
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file gmock-generated-matchers.h
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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>
220  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
221  : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
222 
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 
239  virtual void DescribeTo(::std::ostream* os) const {
240  *os << "are a tuple ";
241  PrintIndices(os);
242  inner_matcher_.DescribeTo(os);
243  }
244 
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:
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.
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:
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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<> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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<> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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> >
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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: "
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_