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 as templates cannot be
254// declared inside of a local class.
255//
256// More Information
257// ================
258//
259// To learn more about using these macros, please search for 'MATCHER'
260// on
261// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md
262
263#define MATCHER(name, description)\
264 class name##Matcher {\
265 public:\
266 template <typename arg_type>\
267 class gmock_Impl : public ::testing::MatcherInterface<\
268 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
269 public:\
270 gmock_Impl()\
271 {}\
272 virtual bool MatchAndExplain(\
273 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
274 ::testing::MatchResultListener* result_listener) const;\
275 virtual void DescribeTo(::std::ostream* gmock_os) const {\
276 *gmock_os << FormatDescription(false);\
277 }\
278 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
279 *gmock_os << FormatDescription(true);\
280 }\
281 private:\
282 ::std::string FormatDescription(bool negation) const {\
283 ::std::string gmock_description = (description);\
284 if (!gmock_description.empty()) {\
285 return gmock_description;\
286 }\
287 return ::testing::internal::FormatMatcherDescription(\
288 negation, #name, \
289 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
290 ::std::tuple<>()));\
291 }\
292 };\
293 template <typename arg_type>\
294 operator ::testing::Matcher<arg_type>() const {\
295 return ::testing::Matcher<arg_type>(\
296 new gmock_Impl<arg_type>());\
297 }\
298 name##Matcher() {\
299 }\
300 private:\
301 };\
302 inline name##Matcher name() {\
303 return name##Matcher();\
304 }\
305 template <typename arg_type>\
306 bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
307 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
308 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
309 const
310
311#define MATCHER_P(name, p0, description)\
312 template <typename p0##_type>\
313 class name##MatcherP {\
314 public:\
315 template <typename arg_type>\
316 class gmock_Impl : public ::testing::MatcherInterface<\
317 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
318 public:\
319 explicit gmock_Impl(p0##_type gmock_p0)\
320 : p0(::std::move(gmock_p0)) {}\
321 virtual bool MatchAndExplain(\
322 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
323 ::testing::MatchResultListener* result_listener) const;\
324 virtual void DescribeTo(::std::ostream* gmock_os) const {\
325 *gmock_os << FormatDescription(false);\
326 }\
327 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
328 *gmock_os << FormatDescription(true);\
329 }\
330 p0##_type const p0;\
331 private:\
332 ::std::string FormatDescription(bool negation) const {\
333 ::std::string gmock_description = (description);\
334 if (!gmock_description.empty()) {\
335 return gmock_description;\
336 }\
337 return ::testing::internal::FormatMatcherDescription(\
338 negation, #name, \
339 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
340 ::std::tuple<p0##_type>(p0)));\
341 }\
342 };\
343 template <typename arg_type>\
344 operator ::testing::Matcher<arg_type>() const {\
345 return ::testing::Matcher<arg_type>(\
346 new gmock_Impl<arg_type>(p0));\
347 }\
348 explicit name##MatcherP(p0##_type gmock_p0) : p0(::std::move(gmock_p0)) {\
349 }\
350 p0##_type const p0;\
351 private:\
352 };\
353 template <typename p0##_type>\
354 inline name##MatcherP<p0##_type> name(p0##_type p0) {\
355 return name##MatcherP<p0##_type>(p0);\
356 }\
357 template <typename p0##_type>\
358 template <typename arg_type>\
359 bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
360 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
361 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
362 const
363
364#define MATCHER_P2(name, p0, p1, description)\
365 template <typename p0##_type, typename p1##_type>\
366 class name##MatcherP2 {\
367 public:\
368 template <typename arg_type>\
369 class gmock_Impl : public ::testing::MatcherInterface<\
370 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
371 public:\
372 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
373 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) {}\
374 virtual bool MatchAndExplain(\
375 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
376 ::testing::MatchResultListener* result_listener) const;\
377 virtual void DescribeTo(::std::ostream* gmock_os) const {\
378 *gmock_os << FormatDescription(false);\
379 }\
380 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
381 *gmock_os << FormatDescription(true);\
382 }\
383 p0##_type const p0;\
384 p1##_type const p1;\
385 private:\
386 ::std::string FormatDescription(bool negation) const {\
387 ::std::string gmock_description = (description);\
388 if (!gmock_description.empty()) {\
389 return gmock_description;\
390 }\
391 return ::testing::internal::FormatMatcherDescription(\
392 negation, #name, \
393 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
394 ::std::tuple<p0##_type, p1##_type>(p0, p1)));\
395 }\
396 };\
397 template <typename arg_type>\
398 operator ::testing::Matcher<arg_type>() const {\
399 return ::testing::Matcher<arg_type>(\
400 new gmock_Impl<arg_type>(p0, p1));\
401 }\
402 name##MatcherP2(p0##_type gmock_p0, \
403 p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
404 p1(::std::move(gmock_p1)) {\
405 }\
406 p0##_type const p0;\
407 p1##_type const p1;\
408 private:\
409 };\
410 template <typename p0##_type, typename p1##_type>\
411 inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
412 p1##_type p1) {\
413 return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
414 }\
415 template <typename p0##_type, typename p1##_type>\
416 template <typename arg_type>\
417 bool name##MatcherP2<p0##_type, \
418 p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
419 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
420 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
421 const
422
423#define MATCHER_P3(name, p0, p1, p2, description)\
424 template <typename p0##_type, typename p1##_type, typename p2##_type>\
425 class name##MatcherP3 {\
426 public:\
427 template <typename arg_type>\
428 class gmock_Impl : public ::testing::MatcherInterface<\
429 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
430 public:\
431 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
432 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
433 p2(::std::move(gmock_p2)) {}\
434 virtual bool MatchAndExplain(\
435 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
436 ::testing::MatchResultListener* result_listener) const;\
437 virtual void DescribeTo(::std::ostream* gmock_os) const {\
438 *gmock_os << FormatDescription(false);\
439 }\
440 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
441 *gmock_os << FormatDescription(true);\
442 }\
443 p0##_type const p0;\
444 p1##_type const p1;\
445 p2##_type const p2;\
446 private:\
447 ::std::string FormatDescription(bool negation) const {\
448 ::std::string gmock_description = (description);\
449 if (!gmock_description.empty()) {\
450 return gmock_description;\
451 }\
452 return ::testing::internal::FormatMatcherDescription(\
453 negation, #name, \
454 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
455 ::std::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, p2)));\
456 }\
457 };\
458 template <typename arg_type>\
459 operator ::testing::Matcher<arg_type>() const {\
460 return ::testing::Matcher<arg_type>(\
461 new gmock_Impl<arg_type>(p0, p1, p2));\
462 }\
463 name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
464 p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
465 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) {\
466 }\
467 p0##_type const p0;\
468 p1##_type const p1;\
469 p2##_type const p2;\
470 private:\
471 };\
472 template <typename p0##_type, typename p1##_type, typename p2##_type>\
473 inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
474 p1##_type p1, p2##_type p2) {\
475 return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
476 }\
477 template <typename p0##_type, typename p1##_type, typename p2##_type>\
478 template <typename arg_type>\
479 bool name##MatcherP3<p0##_type, p1##_type, \
480 p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
481 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
482 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
483 const
484
485#define MATCHER_P4(name, p0, p1, p2, p3, description)\
486 template <typename p0##_type, typename p1##_type, typename p2##_type, \
487 typename p3##_type>\
488 class name##MatcherP4 {\
489 public:\
490 template <typename arg_type>\
491 class gmock_Impl : public ::testing::MatcherInterface<\
492 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
493 public:\
494 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
495 p3##_type gmock_p3)\
496 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
497 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)) {}\
498 virtual bool MatchAndExplain(\
499 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
500 ::testing::MatchResultListener* result_listener) const;\
501 virtual void DescribeTo(::std::ostream* gmock_os) const {\
502 *gmock_os << FormatDescription(false);\
503 }\
504 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
505 *gmock_os << FormatDescription(true);\
506 }\
507 p0##_type const p0;\
508 p1##_type const p1;\
509 p2##_type const p2;\
510 p3##_type const p3;\
511 private:\
512 ::std::string FormatDescription(bool negation) const {\
513 ::std::string gmock_description = (description);\
514 if (!gmock_description.empty()) {\
515 return gmock_description;\
516 }\
517 return ::testing::internal::FormatMatcherDescription(\
518 negation, #name, \
519 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
520 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
521 p1, p2, p3)));\
522 }\
523 };\
524 template <typename arg_type>\
525 operator ::testing::Matcher<arg_type>() const {\
526 return ::testing::Matcher<arg_type>(\
527 new gmock_Impl<arg_type>(p0, p1, p2, p3));\
528 }\
529 name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
530 p2##_type gmock_p2, p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
531 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
532 p3(::std::move(gmock_p3)) {\
533 }\
534 p0##_type const p0;\
535 p1##_type const p1;\
536 p2##_type const p2;\
537 p3##_type const p3;\
538 private:\
539 };\
540 template <typename p0##_type, typename p1##_type, typename p2##_type, \
541 typename p3##_type>\
542 inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
543 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
544 p3##_type p3) {\
545 return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
546 p1, p2, p3);\
547 }\
548 template <typename p0##_type, typename p1##_type, typename p2##_type, \
549 typename p3##_type>\
550 template <typename arg_type>\
551 bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
552 p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
553 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
554 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
555 const
556
557#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
558 template <typename p0##_type, typename p1##_type, typename p2##_type, \
559 typename p3##_type, typename p4##_type>\
560 class name##MatcherP5 {\
561 public:\
562 template <typename arg_type>\
563 class gmock_Impl : public ::testing::MatcherInterface<\
564 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
565 public:\
566 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
567 p3##_type gmock_p3, p4##_type gmock_p4)\
568 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
569 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
570 p4(::std::move(gmock_p4)) {}\
571 virtual bool MatchAndExplain(\
572 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
573 ::testing::MatchResultListener* result_listener) const;\
574 virtual void DescribeTo(::std::ostream* gmock_os) const {\
575 *gmock_os << FormatDescription(false);\
576 }\
577 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
578 *gmock_os << FormatDescription(true);\
579 }\
580 p0##_type const p0;\
581 p1##_type const p1;\
582 p2##_type const p2;\
583 p3##_type const p3;\
584 p4##_type const p4;\
585 private:\
586 ::std::string FormatDescription(bool negation) const {\
587 ::std::string gmock_description = (description);\
588 if (!gmock_description.empty()) {\
589 return gmock_description;\
590 }\
591 return ::testing::internal::FormatMatcherDescription(\
592 negation, #name, \
593 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
594 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
595 p4##_type>(p0, p1, p2, p3, p4)));\
596 }\
597 };\
598 template <typename arg_type>\
599 operator ::testing::Matcher<arg_type>() const {\
600 return ::testing::Matcher<arg_type>(\
601 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
602 }\
603 name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
604 p2##_type gmock_p2, p3##_type gmock_p3, \
605 p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
606 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
607 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) {\
608 }\
609 p0##_type const p0;\
610 p1##_type const p1;\
611 p2##_type const p2;\
612 p3##_type const p3;\
613 p4##_type const p4;\
614 private:\
615 };\
616 template <typename p0##_type, typename p1##_type, typename p2##_type, \
617 typename p3##_type, typename p4##_type>\
618 inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
619 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
620 p4##_type p4) {\
621 return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
622 p4##_type>(p0, p1, p2, p3, p4);\
623 }\
624 template <typename p0##_type, typename p1##_type, typename p2##_type, \
625 typename p3##_type, typename p4##_type>\
626 template <typename arg_type>\
627 bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
628 p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
629 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
630 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
631 const
632
633#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
634 template <typename p0##_type, typename p1##_type, typename p2##_type, \
635 typename p3##_type, typename p4##_type, typename p5##_type>\
636 class name##MatcherP6 {\
637 public:\
638 template <typename arg_type>\
639 class gmock_Impl : public ::testing::MatcherInterface<\
640 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
641 public:\
642 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
643 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
644 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
645 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
646 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)) {}\
647 virtual bool MatchAndExplain(\
648 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
649 ::testing::MatchResultListener* result_listener) const;\
650 virtual void DescribeTo(::std::ostream* gmock_os) const {\
651 *gmock_os << FormatDescription(false);\
652 }\
653 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
654 *gmock_os << FormatDescription(true);\
655 }\
656 p0##_type const p0;\
657 p1##_type const p1;\
658 p2##_type const p2;\
659 p3##_type const p3;\
660 p4##_type const p4;\
661 p5##_type const p5;\
662 private:\
663 ::std::string FormatDescription(bool negation) const {\
664 ::std::string gmock_description = (description);\
665 if (!gmock_description.empty()) {\
666 return gmock_description;\
667 }\
668 return ::testing::internal::FormatMatcherDescription(\
669 negation, #name, \
670 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
671 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
672 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
673 }\
674 };\
675 template <typename arg_type>\
676 operator ::testing::Matcher<arg_type>() const {\
677 return ::testing::Matcher<arg_type>(\
678 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
679 }\
680 name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
681 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
682 p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
683 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
684 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
685 p5(::std::move(gmock_p5)) {\
686 }\
687 p0##_type const p0;\
688 p1##_type const p1;\
689 p2##_type const p2;\
690 p3##_type const p3;\
691 p4##_type const p4;\
692 p5##_type const p5;\
693 private:\
694 };\
695 template <typename p0##_type, typename p1##_type, typename p2##_type, \
696 typename p3##_type, typename p4##_type, typename p5##_type>\
697 inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
698 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
699 p3##_type p3, p4##_type p4, p5##_type p5) {\
700 return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
701 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
702 }\
703 template <typename p0##_type, typename p1##_type, typename p2##_type, \
704 typename p3##_type, typename p4##_type, typename p5##_type>\
705 template <typename arg_type>\
706 bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
707 p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
708 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
709 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
710 const
711
712#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
713 template <typename p0##_type, typename p1##_type, typename p2##_type, \
714 typename p3##_type, typename p4##_type, typename p5##_type, \
715 typename p6##_type>\
716 class name##MatcherP7 {\
717 public:\
718 template <typename arg_type>\
719 class gmock_Impl : public ::testing::MatcherInterface<\
720 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
721 public:\
722 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
723 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
724 p6##_type gmock_p6)\
725 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
726 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
727 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
728 p6(::std::move(gmock_p6)) {}\
729 virtual bool MatchAndExplain(\
730 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
731 ::testing::MatchResultListener* result_listener) const;\
732 virtual void DescribeTo(::std::ostream* gmock_os) const {\
733 *gmock_os << FormatDescription(false);\
734 }\
735 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
736 *gmock_os << FormatDescription(true);\
737 }\
738 p0##_type const p0;\
739 p1##_type const p1;\
740 p2##_type const p2;\
741 p3##_type const p3;\
742 p4##_type const p4;\
743 p5##_type const p5;\
744 p6##_type const p6;\
745 private:\
746 ::std::string FormatDescription(bool negation) const {\
747 ::std::string gmock_description = (description);\
748 if (!gmock_description.empty()) {\
749 return gmock_description;\
750 }\
751 return ::testing::internal::FormatMatcherDescription(\
752 negation, #name, \
753 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
754 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
755 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
756 p6)));\
757 }\
758 };\
759 template <typename arg_type>\
760 operator ::testing::Matcher<arg_type>() const {\
761 return ::testing::Matcher<arg_type>(\
762 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
763 }\
764 name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
765 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
766 p5##_type gmock_p5, p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
767 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
768 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
769 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) {\
770 }\
771 p0##_type const p0;\
772 p1##_type const p1;\
773 p2##_type const p2;\
774 p3##_type const p3;\
775 p4##_type const p4;\
776 p5##_type const p5;\
777 p6##_type const p6;\
778 private:\
779 };\
780 template <typename p0##_type, typename p1##_type, typename p2##_type, \
781 typename p3##_type, typename p4##_type, typename p5##_type, \
782 typename p6##_type>\
783 inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
784 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
785 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
786 p6##_type p6) {\
787 return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
788 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
789 }\
790 template <typename p0##_type, typename p1##_type, typename p2##_type, \
791 typename p3##_type, typename p4##_type, typename p5##_type, \
792 typename p6##_type>\
793 template <typename arg_type>\
794 bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
795 p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
796 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
797 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
798 const
799
800#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
801 template <typename p0##_type, typename p1##_type, typename p2##_type, \
802 typename p3##_type, typename p4##_type, typename p5##_type, \
803 typename p6##_type, typename p7##_type>\
804 class name##MatcherP8 {\
805 public:\
806 template <typename arg_type>\
807 class gmock_Impl : public ::testing::MatcherInterface<\
808 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
809 public:\
810 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
811 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
812 p6##_type gmock_p6, p7##_type gmock_p7)\
813 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
814 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
815 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
816 p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)) {}\
817 virtual bool MatchAndExplain(\
818 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
819 ::testing::MatchResultListener* result_listener) const;\
820 virtual void DescribeTo(::std::ostream* gmock_os) const {\
821 *gmock_os << FormatDescription(false);\
822 }\
823 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
824 *gmock_os << FormatDescription(true);\
825 }\
826 p0##_type const p0;\
827 p1##_type const p1;\
828 p2##_type const p2;\
829 p3##_type const p3;\
830 p4##_type const p4;\
831 p5##_type const p5;\
832 p6##_type const p6;\
833 p7##_type const p7;\
834 private:\
835 ::std::string FormatDescription(bool negation) const {\
836 ::std::string gmock_description = (description);\
837 if (!gmock_description.empty()) {\
838 return gmock_description;\
839 }\
840 return ::testing::internal::FormatMatcherDescription(\
841 negation, #name, \
842 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
843 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
844 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
845 p3, p4, p5, p6, p7)));\
846 }\
847 };\
848 template <typename arg_type>\
849 operator ::testing::Matcher<arg_type>() const {\
850 return ::testing::Matcher<arg_type>(\
851 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
852 }\
853 name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
854 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
855 p5##_type gmock_p5, p6##_type gmock_p6, \
856 p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
857 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
858 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
859 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
860 p7(::std::move(gmock_p7)) {\
861 }\
862 p0##_type const p0;\
863 p1##_type const p1;\
864 p2##_type const p2;\
865 p3##_type const p3;\
866 p4##_type const p4;\
867 p5##_type const p5;\
868 p6##_type const p6;\
869 p7##_type const p7;\
870 private:\
871 };\
872 template <typename p0##_type, typename p1##_type, typename p2##_type, \
873 typename p3##_type, typename p4##_type, typename p5##_type, \
874 typename p6##_type, typename p7##_type>\
875 inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
876 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
877 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
878 p6##_type p6, p7##_type p7) {\
879 return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
880 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
881 p6, p7);\
882 }\
883 template <typename p0##_type, typename p1##_type, typename p2##_type, \
884 typename p3##_type, typename p4##_type, typename p5##_type, \
885 typename p6##_type, typename p7##_type>\
886 template <typename arg_type>\
887 bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
888 p5##_type, p6##_type, \
889 p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
890 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
891 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
892 const
893
894#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
895 template <typename p0##_type, typename p1##_type, typename p2##_type, \
896 typename p3##_type, typename p4##_type, typename p5##_type, \
897 typename p6##_type, typename p7##_type, typename p8##_type>\
898 class name##MatcherP9 {\
899 public:\
900 template <typename arg_type>\
901 class gmock_Impl : public ::testing::MatcherInterface<\
902 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
903 public:\
904 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
905 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
906 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
907 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
908 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
909 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
910 p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
911 p8(::std::move(gmock_p8)) {}\
912 virtual bool MatchAndExplain(\
913 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
914 ::testing::MatchResultListener* result_listener) const;\
915 virtual void DescribeTo(::std::ostream* gmock_os) const {\
916 *gmock_os << FormatDescription(false);\
917 }\
918 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
919 *gmock_os << FormatDescription(true);\
920 }\
921 p0##_type const p0;\
922 p1##_type const p1;\
923 p2##_type const p2;\
924 p3##_type const p3;\
925 p4##_type const p4;\
926 p5##_type const p5;\
927 p6##_type const p6;\
928 p7##_type const p7;\
929 p8##_type const p8;\
930 private:\
931 ::std::string FormatDescription(bool negation) const {\
932 ::std::string gmock_description = (description);\
933 if (!gmock_description.empty()) {\
934 return gmock_description;\
935 }\
936 return ::testing::internal::FormatMatcherDescription(\
937 negation, #name, \
938 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
939 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
940 p4##_type, p5##_type, p6##_type, p7##_type, \
941 p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
942 }\
943 };\
944 template <typename arg_type>\
945 operator ::testing::Matcher<arg_type>() const {\
946 return ::testing::Matcher<arg_type>(\
947 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
948 }\
949 name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
950 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
951 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
952 p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
953 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
954 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
955 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
956 p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) {\
957 }\
958 p0##_type const p0;\
959 p1##_type const p1;\
960 p2##_type const p2;\
961 p3##_type const p3;\
962 p4##_type const p4;\
963 p5##_type const p5;\
964 p6##_type const p6;\
965 p7##_type const p7;\
966 p8##_type const p8;\
967 private:\
968 };\
969 template <typename p0##_type, typename p1##_type, typename p2##_type, \
970 typename p3##_type, typename p4##_type, typename p5##_type, \
971 typename p6##_type, typename p7##_type, typename p8##_type>\
972 inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
973 p4##_type, p5##_type, p6##_type, p7##_type, \
974 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
975 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
976 p8##_type p8) {\
977 return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
978 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
979 p3, p4, p5, p6, p7, p8);\
980 }\
981 template <typename p0##_type, typename p1##_type, typename p2##_type, \
982 typename p3##_type, typename p4##_type, typename p5##_type, \
983 typename p6##_type, typename p7##_type, typename p8##_type>\
984 template <typename arg_type>\
985 bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
986 p5##_type, p6##_type, p7##_type, \
987 p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
988 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
989 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
990 const
991
992#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
993 template <typename p0##_type, typename p1##_type, typename p2##_type, \
994 typename p3##_type, typename p4##_type, typename p5##_type, \
995 typename p6##_type, typename p7##_type, typename p8##_type, \
996 typename p9##_type>\
997 class name##MatcherP10 {\
998 public:\
999 template <typename arg_type>\
1000 class gmock_Impl : public ::testing::MatcherInterface<\
1001 GTEST_REFERENCE_TO_CONST_(arg_type)> {\
1002 public:\
1003 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1004 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1005 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
1006 p9##_type gmock_p9)\
1007 : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
1008 p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
1009 p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
1010 p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
1011 p8(::std::move(gmock_p8)), p9(::std::move(gmock_p9)) {}\
1012 virtual bool MatchAndExplain(\
1013 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1014 ::testing::MatchResultListener* result_listener) const;\
1015 virtual void DescribeTo(::std::ostream* gmock_os) const {\
1016 *gmock_os << FormatDescription(false);\
1017 }\
1018 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
1019 *gmock_os << FormatDescription(true);\
1020 }\
1021 p0##_type const p0;\
1022 p1##_type const p1;\
1023 p2##_type const p2;\
1024 p3##_type const p3;\
1025 p4##_type const p4;\
1026 p5##_type const p5;\
1027 p6##_type const p6;\
1028 p7##_type const p7;\
1029 p8##_type const p8;\
1030 p9##_type const p9;\
1031 private:\
1032 ::std::string FormatDescription(bool negation) const {\
1033 ::std::string gmock_description = (description);\
1034 if (!gmock_description.empty()) {\
1035 return gmock_description;\
1036 }\
1037 return ::testing::internal::FormatMatcherDescription(\
1038 negation, #name, \
1039 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
1040 ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
1041 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
1042 p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
1043 }\
1044 };\
1045 template <typename arg_type>\
1046 operator ::testing::Matcher<arg_type>() const {\
1047 return ::testing::Matcher<arg_type>(\
1048 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
1049 }\
1050 name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
1051 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1052 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1053 p8##_type gmock_p8, p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
1054 p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
1055 p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
1056 p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
1057 p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
1058 p9(::std::move(gmock_p9)) {\
1059 }\
1060 p0##_type const p0;\
1061 p1##_type const p1;\
1062 p2##_type const p2;\
1063 p3##_type const p3;\
1064 p4##_type const p4;\
1065 p5##_type const p5;\
1066 p6##_type const p6;\
1067 p7##_type const p7;\
1068 p8##_type const p8;\
1069 p9##_type const p9;\
1070 private:\
1071 };\
1072 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1073 typename p3##_type, typename p4##_type, typename p5##_type, \
1074 typename p6##_type, typename p7##_type, typename p8##_type, \
1075 typename p9##_type>\
1076 inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
1077 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
1078 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1079 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
1080 p9##_type p9) {\
1081 return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
1082 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
1083 p1, p2, p3, p4, p5, p6, p7, p8, p9);\
1084 }\
1085 template <typename p0##_type, typename p1##_type, typename p2##_type, \
1086 typename p3##_type, typename p4##_type, typename p5##_type, \
1087 typename p6##_type, typename p7##_type, typename p8##_type, \
1088 typename p9##_type>\
1089 template <typename arg_type>\
1090 bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
1091 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
1092 p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
1093 GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
1094 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
1095 const
1096
1097#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
1098