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