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_ 1100