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