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// GOOGLETEST_CM0002 DO NOT DELETE
39
40#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
41#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
42
43#include <iterator>
44#include <sstream>
45#include <string>
46#include <utility>
47#include <vector>
48#include "gmock/gmock-matchers.h"
49
50// The MATCHER* family of macros can be used in a namespace scope to
51// define custom matchers easily.
52//
53// Basic Usage
54// ===========
55//
56// The syntax
57//
58// MATCHER(name, description_string) { statements; }
59//
60// defines a matcher with the given name that executes the statements,
61// which must return a bool to indicate if the match succeeds. Inside
62// the statements, you can refer to the value being matched by 'arg',
63// and refer to its type by 'arg_type'.
64//
65// The description string documents what the matcher does, and is used
66// to generate the failure message when the match fails. Since a
67// MATCHER() is usually defined in a header file shared by multiple
68// C++ source files, we require the description to be a C-string
69// literal to avoid possible side effects. It can be empty, in which
70// case we'll use the sequence of words in the matcher name as the
71// description.
72//
73// For example:
74//
75// MATCHER(IsEven, "") { return (arg % 2) == 0; }
76//
77// allows you to write
78//
79// // Expects mock_foo.Bar(n) to be called where n is even.
80// EXPECT_CALL(mock_foo, Bar(IsEven()));
81//
82// or,
83//
84// // Verifies that the value of some_expression is even.
85// EXPECT_THAT(some_expression, IsEven());
86//
87// If the above assertion fails, it will print something like:
88//
89// Value of: some_expression
90// Expected: is even
91// Actual: 7
92//
93// where the description "is even" is automatically calculated from the
94// matcher name IsEven.
95//
96// Argument Type
97// =============
98//
99// Note that the type of the value being matched (arg_type) is
100// determined by the context in which you use the matcher and is
101// supplied to you by the compiler, so you don't need to worry about
102// declaring it (nor can you). This allows the matcher to be
103// polymorphic. For example, IsEven() can be used to match any type
104// where the value of "(arg % 2) == 0" can be implicitly converted to
105// a bool. In the "Bar(IsEven())" example above, if method Bar()
106// takes an int, 'arg_type' will be int; if it takes an unsigned long,
107// 'arg_type' will be unsigned long; and so on.
108//
109// Parameterizing Matchers
110// =======================
111//
112// Sometimes you'll want to parameterize the matcher. For that you
113// can use another macro:
114//
115// MATCHER_P(name, param_name, description_string) { statements; }
116//
117// For example:
118//
119// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
120//
121// will allow you to write:
122//
123// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
124//
125// which may lead to this message (assuming n is 10):
126//
127// Value of: Blah("a")
128// Expected: has absolute value 10
129// Actual: -9
130//
131// Note that both the matcher description and its parameter are
132// printed, making the message human-friendly.
133//
134// In the matcher definition body, you can write 'foo_type' to
135// reference the type of a parameter named 'foo'. For example, in the
136// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
137// 'value_type' to refer to the type of 'value'.
138//
139// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
140// support multi-parameter matchers.
141//
142// Describing Parameterized Matchers
143// =================================
144//
145// The last argument to MATCHER*() is a string-typed expression. The
146// expression can reference all of the matcher's parameters and a
147// special bool-typed variable named 'negation'. When 'negation' is
148// false, the expression should evaluate to the matcher's description;
149// otherwise it should evaluate to the description of the negation of
150// the matcher. For example,
151//
152// using testing::PrintToString;
153//
154// MATCHER_P2(InClosedRange, low, hi,
155// std::string(negation ? "is not" : "is") + " in range [" +
156// PrintToString(low) + ", " + PrintToString(hi) + "]") {
157// return low <= arg && arg <= hi;
158// }
159// ...
160// EXPECT_THAT(3, InClosedRange(4, 6));
161// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
162//
163// would generate two failures that contain the text:
164//
165// Expected: is in range [4, 6]
166// ...
167// Expected: is not in range [2, 4]
168//
169// If you specify "" as the description, the failure message will
170// contain the sequence of words in the matcher name followed by the
171// parameter values printed as a tuple. For example,
172//
173// MATCHER_P2(InClosedRange, low, hi, "") { ... }
174// ...
175// EXPECT_THAT(3, InClosedRange(4, 6));
176// EXPECT_THAT(3, Not(InClosedRange(2, 4)));
177//
178// would generate two failures that contain the text:
179//
180// Expected: in closed range (4, 6)
181// ...
182// Expected: not (in closed range (2, 4))
183//
184// Types of Matcher Parameters
185// ===========================
186//
187// For the purpose of typing, you can view
188//
189// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
190//
191// as shorthand for
192//
193// template <typename p1_type, ..., typename pk_type>
194// FooMatcherPk<p1_type, ..., pk_type>
195// Foo(p1_type p1, ..., pk_type pk) { ... }
196//
197// When you write Foo(v1, ..., vk), the compiler infers the types of
198// the parameters v1, ..., and vk for you. If you are not happy with
199// the result of the type inference, you can specify the types by
200// explicitly instantiating the template, as in Foo<long, bool>(5,
201// false). As said earlier, you don't get to (or need to) specify
202// 'arg_type' as that's determined by the context in which the matcher
203// is used. You can assign the result of expression Foo(p1, ..., pk)
204// to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This
205// can be useful when composing matchers.
206//
207// While you can instantiate a matcher template with reference types,
208// passing the parameters by pointer usually makes your code more
209// readable. If, however, you still want to pass a parameter by
210// reference, be aware that in the failure message generated by the
211// matcher you will see the value of the referenced object but not its
212// address.
213//
214// Explaining Match Results
215// ========================
216//
217// Sometimes the matcher description alone isn't enough to explain why
218// the match has failed or succeeded. For example, when expecting a
219// long string, it can be very helpful to also print the diff between
220// the expected string and the actual one. To achieve that, you can
221// optionally stream additional information to a special variable
222// named result_listener, whose type is a pointer to class
223// MatchResultListener:
224//
225// MATCHER_P(EqualsLongString, str, "") {
226// if (arg == str) return true;
227//
228// *result_listener << "the difference: "
229/// << DiffStrings(str, arg);
230// return false;
231// }
232//
233// Overloading Matchers
234// ====================
235//
236// You can overload matchers with different numbers of parameters:
237//
238// MATCHER_P(Blah, a, description_string1) { ... }
239// MATCHER_P2(Blah, a, b, description_string2) { ... }
240//
241// Caveats
242// =======
243//
244// When defining a new matcher, you should also consider implementing
245// MatcherInterface or using MakePolymorphicMatcher(). These
246// approaches require more work than the MATCHER* macros, but also
247// give you more control on the types of the value being matched and
248// the matcher parameters, which may leads to better compiler error
249// messages when the matcher is used wrong. They also allow
250// overloading matchers based on parameter types (as opposed to just
251// based on the number of parameters).
252//
253// MATCHER*() can only be used in a namespace scope. The reason is
254// that C++ doesn't yet allow function-local types to be used to
255// instantiate templates. The up-coming C++0x standard will fix this.
256// Once that's done, we'll consider supporting using MATCHER*() inside
257// a function.
258//
259// More Information
260// ================
261//
262// To learn more about using these macros, please search for 'MATCHER'
263// on
264// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md
265
266#define MATCHER(name, description)\
267 class name##Matcher {\
268 public:\
269 template <typename arg_type>\
270 class gmock_Impl : public ::testing::MatcherInterface<\
271 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
272 public:\
273 gmock_Impl()\
274 {}\
275 virtual bool MatchAndExplain(\
276 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
277 ::testing::MatchResultListener* result_listener) const;\
278 virtual void DescribeTo(::std::ostream* gmock_os) const {\
279 *gmock_os << FormatDescription(false);\
280 }\
281 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
282 *gmock_os << FormatDescription(true);\
283 }\
284 private:\
285 ::std::string FormatDescription(bool negation) const {\
286 ::std::string gmock_description = (description);\
287 if (!gmock_description.empty()) {\
288 return gmock_description;\
289 }\
290 return ::testing::internal::FormatMatcherDescription(\
291 negation, #name, \
292 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
293 ::std::tuple<>()));\
294 }\
295 };\
296 template <typename arg_type>\
297 operator ::testing::Matcher<arg_type>() const {\
298 return ::testing::Matcher<arg_type>(\
299 new gmock_Impl<arg_type>());\
300 }\
301 name##Matcher() {\
302 }\
303 private:\
304 };\
305 inline name##Matcher name() {\
306 return name##Matcher();\
307 }\
308 template <typename arg_type>\
309 bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
310 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
311 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
312 const
313
314#define MATCHER_P(name, p0, description)\
315 template <typename p0##_type>\
316 class name##MatcherP {\
317 public:\
318 template <typename arg_type>\
319 class gmock_Impl : public ::testing::MatcherInterface<\
320 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
321 public:\
322 explicit gmock_Impl(p0##_type gmock_p0)\
323 : p0(::std::move(gmock_p0)) {}\
324 virtual bool MatchAndExplain(\
325 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
326 ::testing::MatchResultListener* result_listener) const;\
327 virtual void DescribeTo(::std::ostream* gmock_os) const {\
328 *gmock_os << FormatDescription(false);\
329 }\
330 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
331 *gmock_os << FormatDescription(true);\
332 }\
333 p0##_type const p0;\
334 private:\
335 ::std::string FormatDescription(bool negation) const {\
336 ::std::string gmock_description = (description);\
337 if (!gmock_description.empty()) {\
338 return gmock_description;\
339 }\
340 return ::testing::internal::FormatMatcherDescription(\
341 negation, #name, \
342 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
343 ::std::tuple<p0##_type>(p0)));\
344 }\
345 };\
346 template <typename arg_type>\
347 operator ::testing::Matcher<arg_type>() const {\
348 return ::testing::Matcher<arg_type>(\
349 new gmock_Impl<arg_type>(p0));\
350 }\
351 explicit name##MatcherP(p0##_type gmock_p0) : p0(::std::move(gmock_p0)) {\
352 }\
353 p0##_type const p0;\
354 private:\
355 };\
356 template <typename p0##_type>\
357 inline name##MatcherP<p0##_type> name(p0##_type p0) {\
358 return name##MatcherP<p0##_type>(p0);\
359 }\
360 template <typename p0##_type>\
361 template <typename arg_type>\
362 bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
363 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
364 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
365 const
366
367#define MATCHER_P2(name, p0, p1, description)\
368 template <typename p0##_type, typename p1##_type>\
369 class name##MatcherP2 {\
370 public:\
371 template <typename arg_type>\
372 class gmock_Impl : public ::testing::MatcherInterface<\
373 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
374 public:\
375 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
376 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) {}\
377 virtual bool MatchAndExplain(\
378 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
379 ::testing::MatchResultListener* result_listener) const;\
380 virtual void DescribeTo(::std::ostream* gmock_os) const {\
381 *gmock_os << FormatDescription(false);\
382 }\
383 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
384 *gmock_os << FormatDescription(true);\
385 }\
386 p0##_type const p0;\
387 p1##_type const p1;\
388 private:\
389 ::std::string FormatDescription(bool negation) const {\
390 ::std::string gmock_description = (description);\
391 if (!gmock_description.empty()) {\
392 return gmock_description;\
393 }\
394 return ::testing::internal::FormatMatcherDescription(\
395 negation, #name, \
396 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
397 ::std::tuple<p0##_type, p1##_type>(p0, p1)));\
398 }\
399 };\
400 template <typename arg_type>\
401 operator ::testing::Matcher<arg_type>() const {\
402 return ::testing::Matcher<arg_type>(\
403 new gmock_Impl<arg_type>(p0, p1));\
404 }\
405 name##MatcherP2(p0##_type gmock_p0, \
406 p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
407 p1(::std::move(gmock_p1)) {\
408 }\
409 p0##_type const p0;\
410 p1##_type const p1;\
411 private:\
412 };\
413 template <typename p0##_type, typename p1##_type>\
414 inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
415 p1##_type p1) {\
416 return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
417 }\
418 template <typename p0##_type, typename p1##_type>\
419 template <typename arg_type>\
420 bool name##MatcherP2<p0##_type, \
421 p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
422 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
423 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
424 const
425
426#define MATCHER_P3(name, p0, p1, p2, description)\
427 template <typename p0##_type, typename p1##_type, typename p2##_type>\
428 class name##MatcherP3 {\
429 public:\
430 template <typename arg_type>\
431 class gmock_Impl : public ::testing::MatcherInterface<\
432 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
433 public:\
434 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
435 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
436 p2(::std::move(gmock_p2)) {}\
437 virtual bool MatchAndExplain(\
438 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
439 ::testing::MatchResultListener* result_listener) const;\
440 virtual void DescribeTo(::std::ostream* gmock_os) const {\
441 *gmock_os << FormatDescription(false);\
442 }\
443 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
444 *gmock_os << FormatDescription(true);\
445 }\
446 p0##_type const p0;\
447 p1##_type const p1;\
448 p2##_type const p2;\
449 private:\
450 ::std::string FormatDescription(bool negation) const {\
451 ::std::string gmock_description = (description);\
452 if (!gmock_description.empty()) {\
453 return gmock_description;\
454 }\
455 return ::testing::internal::FormatMatcherDescription(\
456 negation, #name, \
457 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
458 ::std::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, p2)));\
459 }\
460 };\
461 template <typename arg_type>\
462 operator ::testing::Matcher<arg_type>() const {\
463 return ::testing::Matcher<arg_type>(\
464 new gmock_Impl<arg_type>(p0, p1, p2));\
465 }\
466 name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
467 p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
468 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) {\
469 }\
470 p0##_type const p0;\
471 p1##_type const p1;\
472 p2##_type const p2;\
473 private:\
474 };\
475 template <typename p0##_type, typename p1##_type, typename p2##_type>\
476 inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
477 p1##_type p1, p2##_type p2) {\
478 return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
479 }\
480 template <typename p0##_type, typename p1##_type, typename p2##_type>\
481 template <typename arg_type>\
482 bool name##MatcherP3<p0##_type, p1##_type, \
483 p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
484 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
485 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
486 const
487
488#define MATCHER_P4(name, p0, p1, p2, p3, description)\
489 template <typename p0##_type, typename p1##_type, typename p2##_type, \
490 typename p3##_type>\
491 class name##MatcherP4 {\
492 public:\
493 template <typename arg_type>\
494 class gmock_Impl : public ::testing::MatcherInterface<\
495 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
496 public:\
497 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
498 p3##_type gmock_p3)\
499 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
500 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)) {}\
501 virtual bool MatchAndExplain(\
502 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
503 ::testing::MatchResultListener* result_listener) const;\
504 virtual void DescribeTo(::std::ostream* gmock_os) const {\
505 *gmock_os << FormatDescription(false);\
506 }\
507 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
508 *gmock_os << FormatDescription(true);\
509 }\
510 p0##_type const p0;\
511 p1##_type const p1;\
512 p2##_type const p2;\
513 p3##_type const p3;\
514 private:\
515 ::std::string FormatDescription(bool negation) const {\
516 ::std::string gmock_description = (description);\
517 if (!gmock_description.empty()) {\
518 return gmock_description;\
519 }\
520 return ::testing::internal::FormatMatcherDescription(\
521 negation, #name, \
522 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
523 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
524 p1, p2, p3)));\
525 }\
526 };\
527 template <typename arg_type>\
528 operator ::testing::Matcher<arg_type>() const {\
529 return ::testing::Matcher<arg_type>(\
530 new gmock_Impl<arg_type>(p0, p1, p2, p3));\
531 }\
532 name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
533 p2##_type gmock_p2, p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
534 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
535 p3(::std::move(gmock_p3)) {\
536 }\
537 p0##_type const p0;\
538 p1##_type const p1;\
539 p2##_type const p2;\
540 p3##_type const p3;\
541 private:\
542 };\
543 template <typename p0##_type, typename p1##_type, typename p2##_type, \
544 typename p3##_type>\
545 inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
546 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
547 p3##_type p3) {\
548 return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
549 p1, p2, p3);\
550 }\
551 template <typename p0##_type, typename p1##_type, typename p2##_type, \
552 typename p3##_type>\
553 template <typename arg_type>\
554 bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
555 p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
556 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
557 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
558 const
559
560#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
561 template <typename p0##_type, typename p1##_type, typename p2##_type, \
562 typename p3##_type, typename p4##_type>\
563 class name##MatcherP5 {\
564 public:\
565 template <typename arg_type>\
566 class gmock_Impl : public ::testing::MatcherInterface<\
567 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
568 public:\
569 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
570 p3##_type gmock_p3, p4##_type gmock_p4)\
571 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
572 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
573 p4(::std::move(gmock_p4)) {}\
574 virtual bool MatchAndExplain(\
575 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
576 ::testing::MatchResultListener* result_listener) const;\
577 virtual void DescribeTo(::std::ostream* gmock_os) const {\
578 *gmock_os << FormatDescription(false);\
579 }\
580 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
581 *gmock_os << FormatDescription(true);\
582 }\
583 p0##_type const p0;\
584 p1##_type const p1;\
585 p2##_type const p2;\
586 p3##_type const p3;\
587 p4##_type const p4;\
588 private:\
589 ::std::string FormatDescription(bool negation) const {\
590 ::std::string gmock_description = (description);\
591 if (!gmock_description.empty()) {\
592 return gmock_description;\
593 }\
594 return ::testing::internal::FormatMatcherDescription(\
595 negation, #name, \
596 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
597 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
598 p4##_type>(p0, p1, p2, p3, p4)));\
599 }\
600 };\
601 template <typename arg_type>\
602 operator ::testing::Matcher<arg_type>() const {\
603 return ::testing::Matcher<arg_type>(\
604 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
605 }\
606 name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
607 p2##_type gmock_p2, p3##_type gmock_p3, \
608 p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
609 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
610 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) {\
611 }\
612 p0##_type const p0;\
613 p1##_type const p1;\
614 p2##_type const p2;\
615 p3##_type const p3;\
616 p4##_type const p4;\
617 private:\
618 };\
619 template <typename p0##_type, typename p1##_type, typename p2##_type, \
620 typename p3##_type, typename p4##_type>\
621 inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
622 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
623 p4##_type p4) {\
624 return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
625 p4##_type>(p0, p1, p2, p3, p4);\
626 }\
627 template <typename p0##_type, typename p1##_type, typename p2##_type, \
628 typename p3##_type, typename p4##_type>\
629 template <typename arg_type>\
630 bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
631 p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
632 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
633 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
634 const
635
636#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
637 template <typename p0##_type, typename p1##_type, typename p2##_type, \
638 typename p3##_type, typename p4##_type, typename p5##_type>\
639 class name##MatcherP6 {\
640 public:\
641 template <typename arg_type>\
642 class gmock_Impl : public ::testing::MatcherInterface<\
643 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
644 public:\
645 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
646 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
647 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
648 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
649 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)) {}\
650 virtual bool MatchAndExplain(\
651 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
652 ::testing::MatchResultListener* result_listener) const;\
653 virtual void DescribeTo(::std::ostream* gmock_os) const {\
654 *gmock_os << FormatDescription(false);\
655 }\
656 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
657 *gmock_os << FormatDescription(true);\
658 }\
659 p0##_type const p0;\
660 p1##_type const p1;\
661 p2##_type const p2;\
662 p3##_type const p3;\
663 p4##_type const p4;\
664 p5##_type const p5;\
665 private:\
666 ::std::string FormatDescription(bool negation) const {\
667 ::std::string gmock_description = (description);\
668 if (!gmock_description.empty()) {\
669 return gmock_description;\
670 }\
671 return ::testing::internal::FormatMatcherDescription(\
672 negation, #name, \
673 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
674 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
675 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
676 }\
677 };\
678 template <typename arg_type>\
679 operator ::testing::Matcher<arg_type>() const {\
680 return ::testing::Matcher<arg_type>(\
681 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
682 }\
683 name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
684 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
685 p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
686 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
687 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
688 p5(::std::move(gmock_p5)) {\
689 }\
690 p0##_type const p0;\
691 p1##_type const p1;\
692 p2##_type const p2;\
693 p3##_type const p3;\
694 p4##_type const p4;\
695 p5##_type const p5;\
696 private:\
697 };\
698 template <typename p0##_type, typename p1##_type, typename p2##_type, \
699 typename p3##_type, typename p4##_type, typename p5##_type>\
700 inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
701 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
702 p3##_type p3, p4##_type p4, p5##_type p5) {\
703 return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
704 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
705 }\
706 template <typename p0##_type, typename p1##_type, typename p2##_type, \
707 typename p3##_type, typename p4##_type, typename p5##_type>\
708 template <typename arg_type>\
709 bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
710 p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
711 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
712 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
713 const
714
715#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
716 template <typename p0##_type, typename p1##_type, typename p2##_type, \
717 typename p3##_type, typename p4##_type, typename p5##_type, \
718 typename p6##_type>\
719 class name##MatcherP7 {\
720 public:\
721 template <typename arg_type>\
722 class gmock_Impl : public ::testing::MatcherInterface<\
723 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
724 public:\
725 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
726 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
727 p6##_type gmock_p6)\
728 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
729 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
730 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
731 p6(::std::move(gmock_p6)) {}\
732 virtual bool MatchAndExplain(\
733 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
734 ::testing::MatchResultListener* result_listener) const;\
735 virtual void DescribeTo(::std::ostream* gmock_os) const {\
736 *gmock_os << FormatDescription(false);\
737 }\
738 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
739 *gmock_os << FormatDescription(true);\
740 }\
741 p0##_type const p0;\
742 p1##_type const p1;\
743 p2##_type const p2;\
744 p3##_type const p3;\
745 p4##_type const p4;\
746 p5##_type const p5;\
747 p6##_type const p6;\
748 private:\
749 ::std::string FormatDescription(bool negation) const {\
750 ::std::string gmock_description = (description);\
751 if (!gmock_description.empty()) {\
752 return gmock_description;\
753 }\
754 return ::testing::internal::FormatMatcherDescription(\
755 negation, #name, \
756 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
757 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
758 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
759 p6)));\
760 }\
761 };\
762 template <typename arg_type>\
763 operator ::testing::Matcher<arg_type>() const {\
764 return ::testing::Matcher<arg_type>(\
765 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
766 }\
767 name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
768 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
769 p5##_type gmock_p5, p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
770 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
771 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
772 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) {\
773 }\
774 p0##_type const p0;\
775 p1##_type const p1;\
776 p2##_type const p2;\
777 p3##_type const p3;\
778 p4##_type const p4;\
779 p5##_type const p5;\
780 p6##_type const p6;\
781 private:\
782 };\
783 template <typename p0##_type, typename p1##_type, typename p2##_type, \
784 typename p3##_type, typename p4##_type, typename p5##_type, \
785 typename p6##_type>\
786 inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
787 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
788 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
789 p6##_type p6) {\
790 return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
791 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
792 }\
793 template <typename p0##_type, typename p1##_type, typename p2##_type, \
794 typename p3##_type, typename p4##_type, typename p5##_type, \
795 typename p6##_type>\
796 template <typename arg_type>\
797 bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
798 p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
799 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
800 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
801 const
802
803#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
804 template <typename p0##_type, typename p1##_type, typename p2##_type, \
805 typename p3##_type, typename p4##_type, typename p5##_type, \
806 typename p6##_type, typename p7##_type>\
807 class name##MatcherP8 {\
808 public:\
809 template <typename arg_type>\
810 class gmock_Impl : public ::testing::MatcherInterface<\
811 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
812 public:\
813 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
814 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
815 p6##_type gmock_p6, p7##_type gmock_p7)\
816 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
817 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
818 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
819 p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)) {}\
820 virtual bool MatchAndExplain(\
821 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
822 ::testing::MatchResultListener* result_listener) const;\
823 virtual void DescribeTo(::std::ostream* gmock_os) const {\
824 *gmock_os << FormatDescription(false);\
825 }\
826 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
827 *gmock_os << FormatDescription(true);\
828 }\
829 p0##_type const p0;\
830 p1##_type const p1;\
831 p2##_type const p2;\
832 p3##_type const p3;\
833 p4##_type const p4;\
834 p5##_type const p5;\
835 p6##_type const p6;\
836 p7##_type const p7;\
837 private:\
838 ::std::string FormatDescription(bool negation) const {\
839 ::std::string gmock_description = (description);\
840 if (!gmock_description.empty()) {\
841 return gmock_description;\
842 }\
843 return ::testing::internal::FormatMatcherDescription(\
844 negation, #name, \
845 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
846 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
847 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
848 p3, p4, p5, p6, p7)));\
849 }\
850 };\
851 template <typename arg_type>\
852 operator ::testing::Matcher<arg_type>() const {\
853 return ::testing::Matcher<arg_type>(\
854 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
855 }\
856 name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
857 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
858 p5##_type gmock_p5, p6##_type gmock_p6, \
859 p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
860 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
861 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
862 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
863 p7(::std::move(gmock_p7)) {\
864 }\
865 p0##_type const p0;\
866 p1##_type const p1;\
867 p2##_type const p2;\
868 p3##_type const p3;\
869 p4##_type const p4;\
870 p5##_type const p5;\
871 p6##_type const p6;\
872 p7##_type const p7;\
873 private:\
874 };\
875 template <typename p0##_type, typename p1##_type, typename p2##_type, \
876 typename p3##_type, typename p4##_type, typename p5##_type, \
877 typename p6##_type, typename p7##_type>\
878 inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
879 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
880 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
881 p6##_type p6, p7##_type p7) {\
882 return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
883 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
884 p6, p7);\
885 }\
886 template <typename p0##_type, typename p1##_type, typename p2##_type, \
887 typename p3##_type, typename p4##_type, typename p5##_type, \
888 typename p6##_type, typename p7##_type>\
889 template <typename arg_type>\
890 bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
891 p5##_type, p6##_type, \
892 p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
893 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
894 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
895 const
896
897#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
898 template <typename p0##_type, typename p1##_type, typename p2##_type, \
899 typename p3##_type, typename p4##_type, typename p5##_type, \
900 typename p6##_type, typename p7##_type, typename p8##_type>\
901 class name##MatcherP9 {\
902 public:\
903 template <typename arg_type>\
904 class gmock_Impl : public ::testing::MatcherInterface<\
905 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
906 public:\
907 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
908 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
909 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
910 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
911 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
912 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
913 p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
914 p8(::std::move(gmock_p8)) {}\
915 virtual bool MatchAndExplain(\
916 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
917 ::testing::MatchResultListener* result_listener) const;\
918 virtual void DescribeTo(::std::ostream* gmock_os) const {\
919 *gmock_os << FormatDescription(false);\
920 }\
921 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
922 *gmock_os << FormatDescription(true);\
923 }\
924 p0##_type const p0;\
925 p1##_type const p1;\
926 p2##_type const p2;\
927 p3##_type const p3;\
928 p4##_type const p4;\
929 p5##_type const p5;\
930 p6##_type const p6;\
931 p7##_type const p7;\
932 p8##_type const p8;\
933 private:\
934 ::std::string FormatDescription(bool negation) const {\
935 ::std::string gmock_description = (description);\
936 if (!gmock_description.empty()) {\
937 return gmock_description;\
938 }\
939 return ::testing::internal::FormatMatcherDescription(\
940 negation, #name, \
941 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
942 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
943 p4##_type, p5##_type, p6##_type, p7##_type, \
944 p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
945 }\
946 };\
947 template <typename arg_type>\
948 operator ::testing::Matcher<arg_type>() const {\
949 return ::testing::Matcher<arg_type>(\
950 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
951 }\
952 name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
953 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
954 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
955 p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
956 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
957 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
958 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
959 p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) {\
960 }\
961 p0##_type const p0;\
962 p1##_type const p1;\
963 p2##_type const p2;\
964 p3##_type const p3;\
965 p4##_type const p4;\
966 p5##_type const p5;\
967 p6##_type const p6;\
968 p7##_type const p7;\
969 p8##_type const p8;\
970 private:\
971 };\
972 template <typename p0##_type, typename p1##_type, typename p2##_type, \
973 typename p3##_type, typename p4##_type, typename p5##_type, \
974 typename p6##_type, typename p7##_type, typename p8##_type>\
975 inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
976 p4##_type, p5##_type, p6##_type, p7##_type, \
977 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
978 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
979 p8##_type p8) {\
980 return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
981 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
982 p3, p4, p5, p6, p7, p8);\
983 }\
984 template <typename p0##_type, typename p1##_type, typename p2##_type, \
985 typename p3##_type, typename p4##_type, typename p5##_type, \
986 typename p6##_type, typename p7##_type, typename p8##_type>\
987 template <typename arg_type>\
988 bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
989 p5##_type, p6##_type, p7##_type, \
990 p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
991 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
992 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
993 const
994
995#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
996 template <typename p0##_type, typename p1##_type, typename p2##_type, \
997 typename p3##_type, typename p4##_type, typename p5##_type, \
998 typename p6##_type, typename p7##_type, typename p8##_type, \
999 typename p9##_type>\
1000 class name##MatcherP10 {\
1001 public:\
1002 template <typename arg_type>\
1003 class gmock_Impl : public ::testing::MatcherInterface<\
1004 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1005 public:\
1006 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1007 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1008 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
1009 p9##_type gmock_p9)\
1010 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
1011 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
1012 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
1013 p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
1014 p8(::std::move(gmock_p8)), p9(::std::move(gmock_p9)) {}\
1015 virtual bool MatchAndExplain(\
1016 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1017 ::testing::MatchResultListener* result_listener) const;\
1018 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1019 *gmock_os << FormatDescription(false);\
1020 }\
1021 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1022 *gmock_os << FormatDescription(true);\
1023 }\
1024 p0##_type const p0;\
1025 p1##_type const p1;\
1026 p2##_type const p2;\
1027 p3##_type const p3;\
1028 p4##_type const p4;\
1029 p5##_type const p5;\
1030 p6##_type const p6;\
1031 p7##_type const p7;\
1032 p8##_type const p8;\
1033 p9##_type const p9;\
1034 private:\
1035 ::std::string FormatDescription(bool negation) const {\
1036 ::std::string gmock_description = (description);\
1037 if (!gmock_description.empty()) {\
1038 return gmock_description;\
1039 }\
1040 return ::testing::internal::FormatMatcherDescription(\
1041 negation, #name, \
1042 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1043 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1044 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
1045 p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
1046 }\
1047 };\
1048 template <typename arg_type>\
1049 operator ::testing::Matcher<arg_type>() const {\
1050 return ::testing::Matcher<arg_type>(\
1051 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
1052 }\
1053 name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
1054 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1055 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1056 p8##_type gmock_p8, p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
1057 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
1058 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
1059 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
1060 p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
1061 p9(::std::move(gmock_p9)) {\
1062 }\
1063 p0##_type const p0;\
1064 p1##_type const p1;\
1065 p2##_type const p2;\
1066 p3##_type const p3;\
1067 p4##_type const p4;\
1068 p5##_type const p5;\
1069 p6##_type const p6;\
1070 p7##_type const p7;\
1071 p8##_type const p8;\
1072 p9##_type const p9;\
1073 private:\
1074 };\
1075 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1076 typename p3##_type, typename p4##_type, typename p5##_type, \
1077 typename p6##_type, typename p7##_type, typename p8##_type, \
1078 typename p9##_type>\
1079 inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
1080 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
1081 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1082 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
1083 p9##_type p9) {\
1084 return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
1085 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
1086 p1, p2, p3, p4, p5, p6, p7, p8, p9);\
1087 }\
1088 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1089 typename p3##_type, typename p4##_type, typename p5##_type, \
1090 typename p6##_type, typename p7##_type, typename p8##_type, \
1091 typename p9##_type>\
1092 template <typename arg_type>\
1093 bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
1094 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
1095 p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1096 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1097 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1098 const
1099
1100#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
1101