Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/SuperOrxoBros_HS18/src/external/gmock/include/gmock/gmock-generated-matchers.h @ 12177

Last change on this file since 12177 was 12177, checked in by siramesh, 5 years ago

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