llvm/utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h

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