← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/testing/gmock/include/gmock/gmock-generated-matchers.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/testing/gmock/include/gmock/gmock-generated-matchers.h
1
 
// This file was GENERATED by command:
2
 
//     pump.py gmock-generated-matchers.h.pump
3
 
// DO NOT EDIT BY HAND!!!
4
 
 
5
 
// Copyright 2008, Google Inc.
6
 
// All rights reserved.
7
 
//
8
 
// Redistribution and use in source and binary forms, with or without
9
 
// modification, are permitted provided that the following conditions are
10
 
// met:
11
 
//
12
 
//     * Redistributions of source code must retain the above copyright
13
 
// notice, this list of conditions and the following disclaimer.
14
 
//     * Redistributions in binary form must reproduce the above
15
 
// copyright notice, this list of conditions and the following disclaimer
16
 
// in the documentation and/or other materials provided with the
17
 
// distribution.
18
 
//     * Neither the name of Google Inc. nor the names of its
19
 
// contributors may be used to endorse or promote products derived from
20
 
// this software without specific prior written permission.
21
 
//
22
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23
 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24
 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25
 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26
 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27
 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28
 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29
 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30
 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31
 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32
 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
 
 
34
 
// Google Mock - a framework for writing C++ mock classes.
35
 
//
36
 
// This file implements some commonly used variadic matchers.
37
 
 
38
 
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
39
 
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
40
 
 
41
 
#include <iterator>
42
 
#include <sstream>
43
 
#include <string>
44
 
#include <vector>
45
 
#include "gmock/gmock-matchers.h"
46
 
 
47
 
namespace testing {
48
 
namespace internal {
49
 
 
50
 
// The type of the i-th (0-based) field of Tuple.
51
 
#define GMOCK_FIELD_TYPE_(Tuple, i) \
52
 
    typename ::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_