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

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