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