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