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