bloaty/third_party/googletest/googlemock/include/gmock/gmock-generated-matchers.h
Go to the documentation of this file.
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: "
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_

grpc
Author(s):
autogenerated on Fri May 16 2025 02:58:30