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 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ 39 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ 40 41 #include <iterator> 42 #include <sstream> 43 #include <string> 44 #include <vector> 45 #include "gmock/gmock-matchers.h" 46 47 namespace testing { 48 namespace internal { 49 50 // The type of the i-th (0-based) field of Tuple. 51 #define GMOCK_FIELD_TYPE_(Tuple, i) \ 52 typename ::testing::tuple_element<i, Tuple>::type 53 54 // TupleFields<Tuple, k0, ..., kn> is for selecting fields from a 55 // tuple of type Tuple. It has two members: 56 // 57 // type: a tuple type whose i-th field is the ki-th field of Tuple. 58 // GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple. 59 // 60 // For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have: 61 // 62 // type is tuple<int, bool>, and 63 // GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true). 64 65 template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1, 66 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1, 67 int k9 = -1> 68 class TupleFields; 69 70 // This generic version is used when there are 10 selectors. 71 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6, 72 int k7, int k8, int k9> 73 class TupleFields { 74 public: 75 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 76 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 77 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), 78 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6), 79 GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8), 80 GMOCK_FIELD_TYPE_(Tuple, k9)> type; 81 static type GetSelectedFields(const Tuple& t) { 82 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t), 83 get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t)); 84 } 85 }; 86 87 // The following specialization is used for 0 ~ 9 selectors. 88 89 template <class Tuple> 90 class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { 91 public: 92 typedef ::testing::tuple<> type; 93 static type GetSelectedFields(const Tuple& /* t */) { 94 return type(); 95 } 96 }; 97 98 template <class Tuple, int k0> 99 class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> { 100 public: 101 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type; 102 static type GetSelectedFields(const Tuple& t) { 103 return type(get<k0>(t)); 104 } 105 }; 106 107 template <class Tuple, int k0, int k1> 108 class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> { 109 public: 110 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 111 GMOCK_FIELD_TYPE_(Tuple, k1)> type; 112 static type GetSelectedFields(const Tuple& t) { 113 return type(get<k0>(t), get<k1>(t)); 114 } 115 }; 116 117 template <class Tuple, int k0, int k1, int k2> 118 class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> { 119 public: 120 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 121 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type; 122 static type GetSelectedFields(const Tuple& t) { 123 return type(get<k0>(t), get<k1>(t), get<k2>(t)); 124 } 125 }; 126 127 template <class Tuple, int k0, int k1, int k2, int k3> 128 class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> { 129 public: 130 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 131 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 132 GMOCK_FIELD_TYPE_(Tuple, k3)> type; 133 static type GetSelectedFields(const Tuple& t) { 134 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t)); 135 } 136 }; 137 138 template <class Tuple, int k0, int k1, int k2, int k3, int k4> 139 class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> { 140 public: 141 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 142 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 143 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type; 144 static type GetSelectedFields(const Tuple& t) { 145 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t)); 146 } 147 }; 148 149 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5> 150 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> { 151 public: 152 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 153 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 154 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), 155 GMOCK_FIELD_TYPE_(Tuple, k5)> type; 156 static type GetSelectedFields(const Tuple& t) { 157 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t), 158 get<k5>(t)); 159 } 160 }; 161 162 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6> 163 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> { 164 public: 165 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 166 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 167 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), 168 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type; 169 static type GetSelectedFields(const Tuple& t) { 170 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t), 171 get<k5>(t), get<k6>(t)); 172 } 173 }; 174 175 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6, 176 int k7> 177 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> { 178 public: 179 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 180 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 181 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), 182 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6), 183 GMOCK_FIELD_TYPE_(Tuple, k7)> type; 184 static type GetSelectedFields(const Tuple& t) { 185 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t), 186 get<k5>(t), get<k6>(t), get<k7>(t)); 187 } 188 }; 189 190 template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6, 191 int k7, int k8> 192 class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> { 193 public: 194 typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0), 195 GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2), 196 GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4), 197 GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6), 198 GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type; 199 static type GetSelectedFields(const Tuple& t) { 200 return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t), 201 get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t)); 202 } 203 }; 204 205 #undef GMOCK_FIELD_TYPE_ 206 207 // Implements the Args() matcher. 208 template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1, 209 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1, 210 int k9 = -1> 211 class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> { 212 public: 213 // ArgsTuple may have top-level const or reference modifiers. 214 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple; 215 typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, 216 k6, k7, k8, k9>::type SelectedArgs; 217 typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher; 218 219 template <typename InnerMatcher> 220 explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher) 221 : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {} 222 223 virtual bool MatchAndExplain(ArgsTuple args, 224 MatchResultListener* listener) const { 225 const SelectedArgs& selected_args = GetSelectedArgs(args); 226 if (!listener->IsInterested()) 227 return inner_matcher_.Matches(selected_args); 228 229 PrintIndices(listener->stream()); 230 *listener << "are " << PrintToString(selected_args); 231 232 StringMatchResultListener inner_listener; 233 const bool match = inner_matcher_.MatchAndExplain(selected_args, 234 &inner_listener); 235 PrintIfNotEmpty(inner_listener.str(), listener->stream()); 236 return match; 237 } 238 239 virtual void DescribeTo(::std::ostream* os) const { 240 *os << "are a tuple "; 241 PrintIndices(os); 242 inner_matcher_.DescribeTo(os); 243 } 244 245 virtual void DescribeNegationTo(::std::ostream* os) const { 246 *os << "are a tuple "; 247 PrintIndices(os); 248 inner_matcher_.DescribeNegationTo(os); 249 } 250 251 private: 252 static SelectedArgs GetSelectedArgs(ArgsTuple args) { 253 return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, 254 k9>::GetSelectedFields(args); 255 } 256 257 // Prints the indices of the selected fields. 258 static void PrintIndices(::std::ostream* os) { 259 *os << "whose fields ("; 260 const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 }; 261 for (int i = 0; i < 10; i++) { 262 if (indices[i] < 0) 263 break; 264 265 if (i >= 1) 266 *os << ", "; 267 268 *os << "#" << indices[i]; 269 } 270 *os << ") "; 271 } 272 273 const MonomorphicInnerMatcher inner_matcher_; 274 275 GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl); 276 }; 277 278 template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1, 279 int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, 280 int k8 = -1, int k9 = -1> 281 class ArgsMatcher { 282 public: 283 explicit ArgsMatcher(const InnerMatcher& inner_matcher) 284 : inner_matcher_(inner_matcher) {} 285 286 template <typename ArgsTuple> 287 operator Matcher<ArgsTuple>() const { 288 return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5, 289 k6, k7, k8, k9>(inner_matcher_)); 290 } 291 292 private: 293 const InnerMatcher inner_matcher_; 294 295 GTEST_DISALLOW_ASSIGN_(ArgsMatcher); 296 }; 297 298 // A set of metafunctions for computing the result type of AllOf. 299 // AllOf(m1, ..., mN) returns 300 // AllOfResultN<decltype(m1), ..., decltype(mN)>::type. 301 302 // Although AllOf isn't defined for one argument, AllOfResult1 is defined 303 // to simplify the implementation. 304 template <typename M1> 305 struct AllOfResult1 { 306 typedef M1 type; 307 }; 308 309 template <typename M1, typename M2> 310 struct AllOfResult2 { 311 typedef BothOfMatcher< 312 typename AllOfResult1<M1>::type, 313 typename AllOfResult1<M2>::type 314 > type; 315 }; 316 317 template <typename M1, typename M2, typename M3> 318 struct AllOfResult3 { 319 typedef BothOfMatcher< 320 typename AllOfResult1<M1>::type, 321 typename AllOfResult2<M2, M3>::type 322 > type; 323 }; 324 325 template <typename M1, typename M2, typename M3, typename M4> 326 struct AllOfResult4 { 327 typedef BothOfMatcher< 328 typename AllOfResult2<M1, M2>::type, 329 typename AllOfResult2<M3, M4>::type 330 > type; 331 }; 332 333 template <typename M1, typename M2, typename M3, typename M4, typename M5> 334 struct AllOfResult5 { 335 typedef BothOfMatcher< 336 typename AllOfResult2<M1, M2>::type, 337 typename AllOfResult3<M3, M4, M5>::type 338 > type; 339 }; 340 341 template <typename M1, typename M2, typename M3, typename M4, typename M5, 342 typename M6> 343 struct AllOfResult6 { 344 typedef BothOfMatcher< 345 typename AllOfResult3<M1, M2, M3>::type, 346 typename AllOfResult3<M4, M5, M6>::type 347 > type; 348 }; 349 350 template <typename M1, typename M2, typename M3, typename M4, typename M5, 351 typename M6, typename M7> 352 struct AllOfResult7 { 353 typedef BothOfMatcher< 354 typename AllOfResult3<M1, M2, M3>::type, 355 typename AllOfResult4<M4, M5, M6, M7>::type 356 > type; 357 }; 358 359 template <typename M1, typename M2, typename M3, typename M4, typename M5, 360 typename M6, typename M7, typename M8> 361 struct AllOfResult8 { 362 typedef BothOfMatcher< 363 typename AllOfResult4<M1, M2, M3, M4>::type, 364 typename AllOfResult4<M5, M6, M7, M8>::type 365 > type; 366 }; 367 368 template <typename M1, typename M2, typename M3, typename M4, typename M5, 369 typename M6, typename M7, typename M8, typename M9> 370 struct AllOfResult9 { 371 typedef BothOfMatcher< 372 typename AllOfResult4<M1, M2, M3, M4>::type, 373 typename AllOfResult5<M5, M6, M7, M8, M9>::type 374 > type; 375 }; 376 377 template <typename M1, typename M2, typename M3, typename M4, typename M5, 378 typename M6, typename M7, typename M8, typename M9, typename M10> 379 struct AllOfResult10 { 380 typedef BothOfMatcher< 381 typename AllOfResult5<M1, M2, M3, M4, M5>::type, 382 typename AllOfResult5<M6, M7, M8, M9, M10>::type 383 > type; 384 }; 385 386 // A set of metafunctions for computing the result type of AnyOf. 387 // AnyOf(m1, ..., mN) returns 388 // AnyOfResultN<decltype(m1), ..., decltype(mN)>::type. 389 390 // Although AnyOf isn't defined for one argument, AnyOfResult1 is defined 391 // to simplify the implementation. 392 template <typename M1> 393 struct AnyOfResult1 { 394 typedef M1 type; 395 }; 396 397 template <typename M1, typename M2> 398 struct AnyOfResult2 { 399 typedef EitherOfMatcher< 400 typename AnyOfResult1<M1>::type, 401 typename AnyOfResult1<M2>::type 402 > type; 403 }; 404 405 template <typename M1, typename M2, typename M3> 406 struct AnyOfResult3 { 407 typedef EitherOfMatcher< 408 typename AnyOfResult1<M1>::type, 409 typename AnyOfResult2<M2, M3>::type 410 > type; 411 }; 412 413 template <typename M1, typename M2, typename M3, typename M4> 414 struct AnyOfResult4 { 415 typedef EitherOfMatcher< 416 typename AnyOfResult2<M1, M2>::type, 417 typename AnyOfResult2<M3, M4>::type 418 > type; 419 }; 420 421 template <typename M1, typename M2, typename M3, typename M4, typename M5> 422 struct AnyOfResult5 { 423 typedef EitherOfMatcher< 424 typename AnyOfResult2<M1, M2>::type, 425 typename AnyOfResult3<M3, M4, M5>::type 426 > type; 427 }; 428 429 template <typename M1, typename M2, typename M3, typename M4, typename M5, 430 typename M6> 431 struct AnyOfResult6 { 432 typedef EitherOfMatcher< 433 typename AnyOfResult3<M1, M2, M3>::type, 434 typename AnyOfResult3<M4, M5, M6>::type 435 > type; 436 }; 437 438 template <typename M1, typename M2, typename M3, typename M4, typename M5, 439 typename M6, typename M7> 440 struct AnyOfResult7 { 441 typedef EitherOfMatcher< 442 typename AnyOfResult3<M1, M2, M3>::type, 443 typename AnyOfResult4<M4, M5, M6, M7>::type 444 > type; 445 }; 446 447 template <typename M1, typename M2, typename M3, typename M4, typename M5, 448 typename M6, typename M7, typename M8> 449 struct AnyOfResult8 { 450 typedef EitherOfMatcher< 451 typename AnyOfResult4<M1, M2, M3, M4>::type, 452 typename AnyOfResult4<M5, M6, M7, M8>::type 453 > type; 454 }; 455 456 template <typename M1, typename M2, typename M3, typename M4, typename M5, 457 typename M6, typename M7, typename M8, typename M9> 458 struct AnyOfResult9 { 459 typedef EitherOfMatcher< 460 typename AnyOfResult4<M1, M2, M3, M4>::type, 461 typename AnyOfResult5<M5, M6, M7, M8, M9>::type 462 > type; 463 }; 464 465 template <typename M1, typename M2, typename M3, typename M4, typename M5, 466 typename M6, typename M7, typename M8, typename M9, typename M10> 467 struct AnyOfResult10 { 468 typedef EitherOfMatcher< 469 typename AnyOfResult5<M1, M2, M3, M4, M5>::type, 470 typename AnyOfResult5<M6, M7, M8, M9, M10>::type 471 > type; 472 }; 473 474 } // namespace internal 475 476 // Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected 477 // fields of it matches a_matcher. C++ doesn't support default 478 // arguments for function templates, so we have to overload it. 479 template <typename InnerMatcher> 480 inline internal::ArgsMatcher<InnerMatcher> 481 Args(const InnerMatcher& matcher) { 482 return internal::ArgsMatcher<InnerMatcher>(matcher); 483 } 484 485 template <int k1, typename InnerMatcher> 486 inline internal::ArgsMatcher<InnerMatcher, k1> 487 Args(const InnerMatcher& matcher) { 488 return internal::ArgsMatcher<InnerMatcher, k1>(matcher); 489 } 490 491 template <int k1, int k2, typename InnerMatcher> 492 inline internal::ArgsMatcher<InnerMatcher, k1, k2> 493 Args(const InnerMatcher& matcher) { 494 return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher); 495 } 496 497 template <int k1, int k2, int k3, typename InnerMatcher> 498 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3> 499 Args(const InnerMatcher& matcher) { 500 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher); 501 } 502 503 template <int k1, int k2, int k3, int k4, typename InnerMatcher> 504 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4> 505 Args(const InnerMatcher& matcher) { 506 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher); 507 } 508 509 template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher> 510 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5> 511 Args(const InnerMatcher& matcher) { 512 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher); 513 } 514 515 template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher> 516 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6> 517 Args(const InnerMatcher& matcher) { 518 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher); 519 } 520 521 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, 522 typename InnerMatcher> 523 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7> 524 Args(const InnerMatcher& matcher) { 525 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, 526 k7>(matcher); 527 } 528 529 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 530 typename InnerMatcher> 531 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8> 532 Args(const InnerMatcher& matcher) { 533 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, 534 k8>(matcher); 535 } 536 537 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 538 int k9, typename InnerMatcher> 539 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9> 540 Args(const InnerMatcher& matcher) { 541 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, 542 k9>(matcher); 543 } 544 545 template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 546 int k9, int k10, typename InnerMatcher> 547 inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, 548 k10> 549 Args(const InnerMatcher& matcher) { 550 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, 551 k9, k10>(matcher); 552 } 553 554 // ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with 555 // n elements, where the i-th element in the container must 556 // match the i-th argument in the list. Each argument of 557 // ElementsAre() can be either a value or a matcher. We support up to 558 // 10 arguments. 559 // 560 // The use of DecayArray in the implementation allows ElementsAre() 561 // to accept string literals, whose type is const char[N], but we 562 // want to treat them as const char*. 563 // 564 // NOTE: Since ElementsAre() cares about the order of the elements, it 565 // must not be used with containers whose elements's order is 566 // undefined (e.g. hash_map). 567 568 inline internal::ElementsAreMatcher< 569 ::testing::tuple<> > 570 ElementsAre() { 571 typedef ::testing::tuple<> Args; 572 return internal::ElementsAreMatcher<Args>(Args()); 573 } 574 575 template <typename T1> 576 inline internal::ElementsAreMatcher< 577 ::testing::tuple< 578 typename internal::DecayArray<T1>::type> > 579 ElementsAre(const T1& e1) { 580 typedef ::testing::tuple< 581 typename internal::DecayArray<T1>::type> Args; 582 return internal::ElementsAreMatcher<Args>(Args(e1)); 583 } 584 585 template <typename T1, typename T2> 586 inline internal::ElementsAreMatcher< 587 ::testing::tuple< 588 typename internal::DecayArray<T1>::type, 589 typename internal::DecayArray<T2>::type> > 590 ElementsAre(const T1& e1, const T2& e2) { 591 typedef ::testing::tuple< 592 typename internal::DecayArray<T1>::type, 593 typename internal::DecayArray<T2>::type> Args; 594 return internal::ElementsAreMatcher<Args>(Args(e1, e2)); 595 } 596 597 template <typename T1, typename T2, typename T3> 598 inline internal::ElementsAreMatcher< 599 ::testing::tuple< 600 typename internal::DecayArray<T1>::type, 601 typename internal::DecayArray<T2>::type, 602 typename internal::DecayArray<T3>::type> > 603 ElementsAre(const T1& e1, const T2& e2, const T3& e3) { 604 typedef ::testing::tuple< 605 typename internal::DecayArray<T1>::type, 606 typename internal::DecayArray<T2>::type, 607 typename internal::DecayArray<T3>::type> Args; 608 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3)); 609 } 610 611 template <typename T1, typename T2, typename T3, typename T4> 612 inline internal::ElementsAreMatcher< 613 ::testing::tuple< 614 typename internal::DecayArray<T1>::type, 615 typename internal::DecayArray<T2>::type, 616 typename internal::DecayArray<T3>::type, 617 typename internal::DecayArray<T4>::type> > 618 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) { 619 typedef ::testing::tuple< 620 typename internal::DecayArray<T1>::type, 621 typename internal::DecayArray<T2>::type, 622 typename internal::DecayArray<T3>::type, 623 typename internal::DecayArray<T4>::type> Args; 624 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4)); 625 } 626 627 template <typename T1, typename T2, typename T3, typename T4, typename T5> 628 inline internal::ElementsAreMatcher< 629 ::testing::tuple< 630 typename internal::DecayArray<T1>::type, 631 typename internal::DecayArray<T2>::type, 632 typename internal::DecayArray<T3>::type, 633 typename internal::DecayArray<T4>::type, 634 typename internal::DecayArray<T5>::type> > 635 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 636 const T5& e5) { 637 typedef ::testing::tuple< 638 typename internal::DecayArray<T1>::type, 639 typename internal::DecayArray<T2>::type, 640 typename internal::DecayArray<T3>::type, 641 typename internal::DecayArray<T4>::type, 642 typename internal::DecayArray<T5>::type> Args; 643 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5)); 644 } 645 646 template <typename T1, typename T2, typename T3, typename T4, typename T5, 647 typename T6> 648 inline internal::ElementsAreMatcher< 649 ::testing::tuple< 650 typename internal::DecayArray<T1>::type, 651 typename internal::DecayArray<T2>::type, 652 typename internal::DecayArray<T3>::type, 653 typename internal::DecayArray<T4>::type, 654 typename internal::DecayArray<T5>::type, 655 typename internal::DecayArray<T6>::type> > 656 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 657 const T5& e5, const T6& e6) { 658 typedef ::testing::tuple< 659 typename internal::DecayArray<T1>::type, 660 typename internal::DecayArray<T2>::type, 661 typename internal::DecayArray<T3>::type, 662 typename internal::DecayArray<T4>::type, 663 typename internal::DecayArray<T5>::type, 664 typename internal::DecayArray<T6>::type> Args; 665 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6)); 666 } 667 668 template <typename T1, typename T2, typename T3, typename T4, typename T5, 669 typename T6, typename T7> 670 inline internal::ElementsAreMatcher< 671 ::testing::tuple< 672 typename internal::DecayArray<T1>::type, 673 typename internal::DecayArray<T2>::type, 674 typename internal::DecayArray<T3>::type, 675 typename internal::DecayArray<T4>::type, 676 typename internal::DecayArray<T5>::type, 677 typename internal::DecayArray<T6>::type, 678 typename internal::DecayArray<T7>::type> > 679 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 680 const T5& e5, const T6& e6, const T7& e7) { 681 typedef ::testing::tuple< 682 typename internal::DecayArray<T1>::type, 683 typename internal::DecayArray<T2>::type, 684 typename internal::DecayArray<T3>::type, 685 typename internal::DecayArray<T4>::type, 686 typename internal::DecayArray<T5>::type, 687 typename internal::DecayArray<T6>::type, 688 typename internal::DecayArray<T7>::type> Args; 689 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7)); 690 } 691 692 template <typename T1, typename T2, typename T3, typename T4, typename T5, 693 typename T6, typename T7, typename T8> 694 inline internal::ElementsAreMatcher< 695 ::testing::tuple< 696 typename internal::DecayArray<T1>::type, 697 typename internal::DecayArray<T2>::type, 698 typename internal::DecayArray<T3>::type, 699 typename internal::DecayArray<T4>::type, 700 typename internal::DecayArray<T5>::type, 701 typename internal::DecayArray<T6>::type, 702 typename internal::DecayArray<T7>::type, 703 typename internal::DecayArray<T8>::type> > 704 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 705 const T5& e5, const T6& e6, const T7& e7, const T8& e8) { 706 typedef ::testing::tuple< 707 typename internal::DecayArray<T1>::type, 708 typename internal::DecayArray<T2>::type, 709 typename internal::DecayArray<T3>::type, 710 typename internal::DecayArray<T4>::type, 711 typename internal::DecayArray<T5>::type, 712 typename internal::DecayArray<T6>::type, 713 typename internal::DecayArray<T7>::type, 714 typename internal::DecayArray<T8>::type> Args; 715 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7, 716 e8)); 717 } 718 719 template <typename T1, typename T2, typename T3, typename T4, typename T5, 720 typename T6, typename T7, typename T8, typename T9> 721 inline internal::ElementsAreMatcher< 722 ::testing::tuple< 723 typename internal::DecayArray<T1>::type, 724 typename internal::DecayArray<T2>::type, 725 typename internal::DecayArray<T3>::type, 726 typename internal::DecayArray<T4>::type, 727 typename internal::DecayArray<T5>::type, 728 typename internal::DecayArray<T6>::type, 729 typename internal::DecayArray<T7>::type, 730 typename internal::DecayArray<T8>::type, 731 typename internal::DecayArray<T9>::type> > 732 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 733 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) { 734 typedef ::testing::tuple< 735 typename internal::DecayArray<T1>::type, 736 typename internal::DecayArray<T2>::type, 737 typename internal::DecayArray<T3>::type, 738 typename internal::DecayArray<T4>::type, 739 typename internal::DecayArray<T5>::type, 740 typename internal::DecayArray<T6>::type, 741 typename internal::DecayArray<T7>::type, 742 typename internal::DecayArray<T8>::type, 743 typename internal::DecayArray<T9>::type> Args; 744 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7, 745 e8, e9)); 746 } 747 748 template <typename T1, typename T2, typename T3, typename T4, typename T5, 749 typename T6, typename T7, typename T8, typename T9, typename T10> 750 inline internal::ElementsAreMatcher< 751 ::testing::tuple< 752 typename internal::DecayArray<T1>::type, 753 typename internal::DecayArray<T2>::type, 754 typename internal::DecayArray<T3>::type, 755 typename internal::DecayArray<T4>::type, 756 typename internal::DecayArray<T5>::type, 757 typename internal::DecayArray<T6>::type, 758 typename internal::DecayArray<T7>::type, 759 typename internal::DecayArray<T8>::type, 760 typename internal::DecayArray<T9>::type, 761 typename internal::DecayArray<T10>::type> > 762 ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 763 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9, 764 const T10& e10) { 765 typedef ::testing::tuple< 766 typename internal::DecayArray<T1>::type, 767 typename internal::DecayArray<T2>::type, 768 typename internal::DecayArray<T3>::type, 769 typename internal::DecayArray<T4>::type, 770 typename internal::DecayArray<T5>::type, 771 typename internal::DecayArray<T6>::type, 772 typename internal::DecayArray<T7>::type, 773 typename internal::DecayArray<T8>::type, 774 typename internal::DecayArray<T9>::type, 775 typename internal::DecayArray<T10>::type> Args; 776 return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7, 777 e8, e9, e10)); 778 } 779 780 // UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension 781 // that matches n elements in any order. We support up to n=10 arguments. 782 783 inline internal::UnorderedElementsAreMatcher< 784 ::testing::tuple<> > 785 UnorderedElementsAre() { 786 typedef ::testing::tuple<> Args; 787 return internal::UnorderedElementsAreMatcher<Args>(Args()); 788 } 789 790 template <typename T1> 791 inline internal::UnorderedElementsAreMatcher< 792 ::testing::tuple< 793 typename internal::DecayArray<T1>::type> > 794 UnorderedElementsAre(const T1& e1) { 795 typedef ::testing::tuple< 796 typename internal::DecayArray<T1>::type> Args; 797 return internal::UnorderedElementsAreMatcher<Args>(Args(e1)); 798 } 799 800 template <typename T1, typename T2> 801 inline internal::UnorderedElementsAreMatcher< 802 ::testing::tuple< 803 typename internal::DecayArray<T1>::type, 804 typename internal::DecayArray<T2>::type> > 805 UnorderedElementsAre(const T1& e1, const T2& e2) { 806 typedef ::testing::tuple< 807 typename internal::DecayArray<T1>::type, 808 typename internal::DecayArray<T2>::type> Args; 809 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2)); 810 } 811 812 template <typename T1, typename T2, typename T3> 813 inline internal::UnorderedElementsAreMatcher< 814 ::testing::tuple< 815 typename internal::DecayArray<T1>::type, 816 typename internal::DecayArray<T2>::type, 817 typename internal::DecayArray<T3>::type> > 818 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) { 819 typedef ::testing::tuple< 820 typename internal::DecayArray<T1>::type, 821 typename internal::DecayArray<T2>::type, 822 typename internal::DecayArray<T3>::type> Args; 823 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3)); 824 } 825 826 template <typename T1, typename T2, typename T3, typename T4> 827 inline internal::UnorderedElementsAreMatcher< 828 ::testing::tuple< 829 typename internal::DecayArray<T1>::type, 830 typename internal::DecayArray<T2>::type, 831 typename internal::DecayArray<T3>::type, 832 typename internal::DecayArray<T4>::type> > 833 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) { 834 typedef ::testing::tuple< 835 typename internal::DecayArray<T1>::type, 836 typename internal::DecayArray<T2>::type, 837 typename internal::DecayArray<T3>::type, 838 typename internal::DecayArray<T4>::type> Args; 839 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4)); 840 } 841 842 template <typename T1, typename T2, typename T3, typename T4, typename T5> 843 inline internal::UnorderedElementsAreMatcher< 844 ::testing::tuple< 845 typename internal::DecayArray<T1>::type, 846 typename internal::DecayArray<T2>::type, 847 typename internal::DecayArray<T3>::type, 848 typename internal::DecayArray<T4>::type, 849 typename internal::DecayArray<T5>::type> > 850 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 851 const T5& e5) { 852 typedef ::testing::tuple< 853 typename internal::DecayArray<T1>::type, 854 typename internal::DecayArray<T2>::type, 855 typename internal::DecayArray<T3>::type, 856 typename internal::DecayArray<T4>::type, 857 typename internal::DecayArray<T5>::type> Args; 858 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5)); 859 } 860 861 template <typename T1, typename T2, typename T3, typename T4, typename T5, 862 typename T6> 863 inline internal::UnorderedElementsAreMatcher< 864 ::testing::tuple< 865 typename internal::DecayArray<T1>::type, 866 typename internal::DecayArray<T2>::type, 867 typename internal::DecayArray<T3>::type, 868 typename internal::DecayArray<T4>::type, 869 typename internal::DecayArray<T5>::type, 870 typename internal::DecayArray<T6>::type> > 871 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 872 const T5& e5, const T6& e6) { 873 typedef ::testing::tuple< 874 typename internal::DecayArray<T1>::type, 875 typename internal::DecayArray<T2>::type, 876 typename internal::DecayArray<T3>::type, 877 typename internal::DecayArray<T4>::type, 878 typename internal::DecayArray<T5>::type, 879 typename internal::DecayArray<T6>::type> Args; 880 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, 881 e6)); 882 } 883 884 template <typename T1, typename T2, typename T3, typename T4, typename T5, 885 typename T6, typename T7> 886 inline internal::UnorderedElementsAreMatcher< 887 ::testing::tuple< 888 typename internal::DecayArray<T1>::type, 889 typename internal::DecayArray<T2>::type, 890 typename internal::DecayArray<T3>::type, 891 typename internal::DecayArray<T4>::type, 892 typename internal::DecayArray<T5>::type, 893 typename internal::DecayArray<T6>::type, 894 typename internal::DecayArray<T7>::type> > 895 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 896 const T5& e5, const T6& e6, const T7& e7) { 897 typedef ::testing::tuple< 898 typename internal::DecayArray<T1>::type, 899 typename internal::DecayArray<T2>::type, 900 typename internal::DecayArray<T3>::type, 901 typename internal::DecayArray<T4>::type, 902 typename internal::DecayArray<T5>::type, 903 typename internal::DecayArray<T6>::type, 904 typename internal::DecayArray<T7>::type> Args; 905 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, 906 e6, e7)); 907 } 908 909 template <typename T1, typename T2, typename T3, typename T4, typename T5, 910 typename T6, typename T7, typename T8> 911 inline internal::UnorderedElementsAreMatcher< 912 ::testing::tuple< 913 typename internal::DecayArray<T1>::type, 914 typename internal::DecayArray<T2>::type, 915 typename internal::DecayArray<T3>::type, 916 typename internal::DecayArray<T4>::type, 917 typename internal::DecayArray<T5>::type, 918 typename internal::DecayArray<T6>::type, 919 typename internal::DecayArray<T7>::type, 920 typename internal::DecayArray<T8>::type> > 921 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 922 const T5& e5, const T6& e6, const T7& e7, const T8& e8) { 923 typedef ::testing::tuple< 924 typename internal::DecayArray<T1>::type, 925 typename internal::DecayArray<T2>::type, 926 typename internal::DecayArray<T3>::type, 927 typename internal::DecayArray<T4>::type, 928 typename internal::DecayArray<T5>::type, 929 typename internal::DecayArray<T6>::type, 930 typename internal::DecayArray<T7>::type, 931 typename internal::DecayArray<T8>::type> Args; 932 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, 933 e6, e7, e8)); 934 } 935 936 template <typename T1, typename T2, typename T3, typename T4, typename T5, 937 typename T6, typename T7, typename T8, typename T9> 938 inline internal::UnorderedElementsAreMatcher< 939 ::testing::tuple< 940 typename internal::DecayArray<T1>::type, 941 typename internal::DecayArray<T2>::type, 942 typename internal::DecayArray<T3>::type, 943 typename internal::DecayArray<T4>::type, 944 typename internal::DecayArray<T5>::type, 945 typename internal::DecayArray<T6>::type, 946 typename internal::DecayArray<T7>::type, 947 typename internal::DecayArray<T8>::type, 948 typename internal::DecayArray<T9>::type> > 949 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 950 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) { 951 typedef ::testing::tuple< 952 typename internal::DecayArray<T1>::type, 953 typename internal::DecayArray<T2>::type, 954 typename internal::DecayArray<T3>::type, 955 typename internal::DecayArray<T4>::type, 956 typename internal::DecayArray<T5>::type, 957 typename internal::DecayArray<T6>::type, 958 typename internal::DecayArray<T7>::type, 959 typename internal::DecayArray<T8>::type, 960 typename internal::DecayArray<T9>::type> Args; 961 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, 962 e6, e7, e8, e9)); 963 } 964 965 template <typename T1, typename T2, typename T3, typename T4, typename T5, 966 typename T6, typename T7, typename T8, typename T9, typename T10> 967 inline internal::UnorderedElementsAreMatcher< 968 ::testing::tuple< 969 typename internal::DecayArray<T1>::type, 970 typename internal::DecayArray<T2>::type, 971 typename internal::DecayArray<T3>::type, 972 typename internal::DecayArray<T4>::type, 973 typename internal::DecayArray<T5>::type, 974 typename internal::DecayArray<T6>::type, 975 typename internal::DecayArray<T7>::type, 976 typename internal::DecayArray<T8>::type, 977 typename internal::DecayArray<T9>::type, 978 typename internal::DecayArray<T10>::type> > 979 UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4, 980 const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9, 981 const T10& e10) { 982 typedef ::testing::tuple< 983 typename internal::DecayArray<T1>::type, 984 typename internal::DecayArray<T2>::type, 985 typename internal::DecayArray<T3>::type, 986 typename internal::DecayArray<T4>::type, 987 typename internal::DecayArray<T5>::type, 988 typename internal::DecayArray<T6>::type, 989 typename internal::DecayArray<T7>::type, 990 typename internal::DecayArray<T8>::type, 991 typename internal::DecayArray<T9>::type, 992 typename internal::DecayArray<T10>::type> Args; 993 return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, 994 e6, e7, e8, e9, e10)); 995 } 996 997 // AllOf(m1, m2, ..., mk) matches any value that matches all of the given 998 // sub-matchers. AllOf is called fully qualified to prevent ADL from firing. 999 1000 template <typename M1, typename M2> 1001 inline typename internal::AllOfResult2<M1, M2>::type 1002 AllOf(M1 m1, M2 m2) { 1003 return typename internal::AllOfResult2<M1, M2>::type( 1004 m1, 1005 m2); 1006 } 1007 1008 template <typename M1, typename M2, typename M3> 1009 inline typename internal::AllOfResult3<M1, M2, M3>::type 1010 AllOf(M1 m1, M2 m2, M3 m3) { 1011 return typename internal::AllOfResult3<M1, M2, M3>::type( 1012 m1, 1013 ::testing::AllOf(m2, m3)); 1014 } 1015 1016 template <typename M1, typename M2, typename M3, typename M4> 1017 inline typename internal::AllOfResult4<M1, M2, M3, M4>::type 1018 AllOf(M1 m1, M2 m2, M3 m3, M4 m4) { 1019 return typename internal::AllOfResult4<M1, M2, M3, M4>::type( 1020 ::testing::AllOf(m1, m2), 1021 ::testing::AllOf(m3, m4)); 1022 } 1023 1024 template <typename M1, typename M2, typename M3, typename M4, typename M5> 1025 inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type 1026 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) { 1027 return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type( 1028 ::testing::AllOf(m1, m2), 1029 ::testing::AllOf(m3, m4, m5)); 1030 } 1031 1032 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1033 typename M6> 1034 inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type 1035 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) { 1036 return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type( 1037 ::testing::AllOf(m1, m2, m3), 1038 ::testing::AllOf(m4, m5, m6)); 1039 } 1040 1041 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1042 typename M6, typename M7> 1043 inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type 1044 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) { 1045 return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type( 1046 ::testing::AllOf(m1, m2, m3), 1047 ::testing::AllOf(m4, m5, m6, m7)); 1048 } 1049 1050 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1051 typename M6, typename M7, typename M8> 1052 inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type 1053 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) { 1054 return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type( 1055 ::testing::AllOf(m1, m2, m3, m4), 1056 ::testing::AllOf(m5, m6, m7, m8)); 1057 } 1058 1059 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1060 typename M6, typename M7, typename M8, typename M9> 1061 inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type 1062 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) { 1063 return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, 1064 M9>::type( 1065 ::testing::AllOf(m1, m2, m3, m4), 1066 ::testing::AllOf(m5, m6, m7, m8, m9)); 1067 } 1068 1069 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1070 typename M6, typename M7, typename M8, typename M9, typename M10> 1071 inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9, 1072 M10>::type 1073 AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) { 1074 return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9, 1075 M10>::type( 1076 ::testing::AllOf(m1, m2, m3, m4, m5), 1077 ::testing::AllOf(m6, m7, m8, m9, m10)); 1078 } 1079 1080 // AnyOf(m1, m2, ..., mk) matches any value that matches any of the given 1081 // sub-matchers. AnyOf is called fully qualified to prevent ADL from firing. 1082 1083 template <typename M1, typename M2> 1084 inline typename internal::AnyOfResult2<M1, M2>::type 1085 AnyOf(M1 m1, M2 m2) { 1086 return typename internal::AnyOfResult2<M1, M2>::type( 1087 m1, 1088 m2); 1089 } 1090 1091 template <typename M1, typename M2, typename M3> 1092 inline typename internal::AnyOfResult3<M1, M2, M3>::type 1093 AnyOf(M1 m1, M2 m2, M3 m3) { 1094 return typename internal::AnyOfResult3<M1, M2, M3>::type( 1095 m1, 1096 ::testing::AnyOf(m2, m3)); 1097 } 1098 1099 template <typename M1, typename M2, typename M3, typename M4> 1100 inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type 1101 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) { 1102 return typename internal::AnyOfResult4<M1, M2, M3, M4>::type( 1103 ::testing::AnyOf(m1, m2), 1104 ::testing::AnyOf(m3, m4)); 1105 } 1106 1107 template <typename M1, typename M2, typename M3, typename M4, typename M5> 1108 inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type 1109 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) { 1110 return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type( 1111 ::testing::AnyOf(m1, m2), 1112 ::testing::AnyOf(m3, m4, m5)); 1113 } 1114 1115 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1116 typename M6> 1117 inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type 1118 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) { 1119 return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type( 1120 ::testing::AnyOf(m1, m2, m3), 1121 ::testing::AnyOf(m4, m5, m6)); 1122 } 1123 1124 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1125 typename M6, typename M7> 1126 inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type 1127 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) { 1128 return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type( 1129 ::testing::AnyOf(m1, m2, m3), 1130 ::testing::AnyOf(m4, m5, m6, m7)); 1131 } 1132 1133 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1134 typename M6, typename M7, typename M8> 1135 inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type 1136 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) { 1137 return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type( 1138 ::testing::AnyOf(m1, m2, m3, m4), 1139 ::testing::AnyOf(m5, m6, m7, m8)); 1140 } 1141 1142 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1143 typename M6, typename M7, typename M8, typename M9> 1144 inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type 1145 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) { 1146 return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, 1147 M9>::type( 1148 ::testing::AnyOf(m1, m2, m3, m4), 1149 ::testing::AnyOf(m5, m6, m7, m8, m9)); 1150 } 1151 1152 template <typename M1, typename M2, typename M3, typename M4, typename M5, 1153 typename M6, typename M7, typename M8, typename M9, typename M10> 1154 inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9, 1155 M10>::type 1156 AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) { 1157 return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9, 1158 M10>::type( 1159 ::testing::AnyOf(m1, m2, m3, m4, m5), 1160 ::testing::AnyOf(m6, m7, m8, m9, m10)); 1161 } 1162 1163 } // namespace testing 1164 1165 1166 // The MATCHER* family of macros can be used in a namespace scope to 1167 // define custom matchers easily. 1168 // 1169 // Basic Usage 1170 // =========== 1171 // 1172 // The syntax 1173 // 1174 // MATCHER(name, description_string) { statements; } 1175 // 1176 // defines a matcher with the given name that executes the statements, 1177 // which must return a bool to indicate if the match succeeds. Inside 1178 // the statements, you can refer to the value being matched by 'arg', 1179 // and refer to its type by 'arg_type'. 1180 // 1181 // The description string documents what the matcher does, and is used 1182 // to generate the failure message when the match fails. Since a 1183 // MATCHER() is usually defined in a header file shared by multiple 1184 // C++ source files, we require the description to be a C-string 1185 // literal to avoid possible side effects. It can be empty, in which 1186 // case we'll use the sequence of words in the matcher name as the 1187 // description. 1188 // 1189 // For example: 1190 // 1191 // MATCHER(IsEven, "") { return (arg % 2) == 0; } 1192 // 1193 // allows you to write 1194 // 1195 // // Expects mock_foo.Bar(n) to be called where n is even. 1196 // EXPECT_CALL(mock_foo, Bar(IsEven())); 1197 // 1198 // or, 1199 // 1200 // // Verifies that the value of some_expression is even. 1201 // EXPECT_THAT(some_expression, IsEven()); 1202 // 1203 // If the above assertion fails, it will print something like: 1204 // 1205 // Value of: some_expression 1206 // Expected: is even 1207 // Actual: 7 1208 // 1209 // where the description "is even" is automatically calculated from the 1210 // matcher name IsEven. 1211 // 1212 // Argument Type 1213 // ============= 1214 // 1215 // Note that the type of the value being matched (arg_type) is 1216 // determined by the context in which you use the matcher and is 1217 // supplied to you by the compiler, so you don't need to worry about 1218 // declaring it (nor can you). This allows the matcher to be 1219 // polymorphic. For example, IsEven() can be used to match any type 1220 // where the value of "(arg % 2) == 0" can be implicitly converted to 1221 // a bool. In the "Bar(IsEven())" example above, if method Bar() 1222 // takes an int, 'arg_type' will be int; if it takes an unsigned long, 1223 // 'arg_type' will be unsigned long; and so on. 1224 // 1225 // Parameterizing Matchers 1226 // ======================= 1227 // 1228 // Sometimes you'll want to parameterize the matcher. For that you 1229 // can use another macro: 1230 // 1231 // MATCHER_P(name, param_name, description_string) { statements; } 1232 // 1233 // For example: 1234 // 1235 // MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } 1236 // 1237 // will allow you to write: 1238 // 1239 // EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); 1240 // 1241 // which may lead to this message (assuming n is 10): 1242 // 1243 // Value of: Blah("a") 1244 // Expected: has absolute value 10 1245 // Actual: -9 1246 // 1247 // Note that both the matcher description and its parameter are 1248 // printed, making the message human-friendly. 1249 // 1250 // In the matcher definition body, you can write 'foo_type' to 1251 // reference the type of a parameter named 'foo'. For example, in the 1252 // body of MATCHER_P(HasAbsoluteValue, value) above, you can write 1253 // 'value_type' to refer to the type of 'value'. 1254 // 1255 // We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to 1256 // support multi-parameter matchers. 1257 // 1258 // Describing Parameterized Matchers 1259 // ================================= 1260 // 1261 // The last argument to MATCHER*() is a string-typed expression. The 1262 // expression can reference all of the matcher's parameters and a 1263 // special bool-typed variable named 'negation'. When 'negation' is 1264 // false, the expression should evaluate to the matcher's description; 1265 // otherwise it should evaluate to the description of the negation of 1266 // the matcher. For example, 1267 // 1268 // using testing::PrintToString; 1269 // 1270 // MATCHER_P2(InClosedRange, low, hi, 1271 // string(negation ? "is not" : "is") + " in range [" + 1272 // PrintToString(low) + ", " + PrintToString(hi) + "]") { 1273 // return low <= arg && arg <= hi; 1274 // } 1275 // ... 1276 // EXPECT_THAT(3, InClosedRange(4, 6)); 1277 // EXPECT_THAT(3, Not(InClosedRange(2, 4))); 1278 // 1279 // would generate two failures that contain the text: 1280 // 1281 // Expected: is in range [4, 6] 1282 // ... 1283 // Expected: is not in range [2, 4] 1284 // 1285 // If you specify "" as the description, the failure message will 1286 // contain the sequence of words in the matcher name followed by the 1287 // parameter values printed as a tuple. For example, 1288 // 1289 // MATCHER_P2(InClosedRange, low, hi, "") { ... } 1290 // ... 1291 // EXPECT_THAT(3, InClosedRange(4, 6)); 1292 // EXPECT_THAT(3, Not(InClosedRange(2, 4))); 1293 // 1294 // would generate two failures that contain the text: 1295 // 1296 // Expected: in closed range (4, 6) 1297 // ... 1298 // Expected: not (in closed range (2, 4)) 1299 // 1300 // Types of Matcher Parameters 1301 // =========================== 1302 // 1303 // For the purpose of typing, you can view 1304 // 1305 // MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } 1306 // 1307 // as shorthand for 1308 // 1309 // template <typename p1_type, ..., typename pk_type> 1310 // FooMatcherPk<p1_type, ..., pk_type> 1311 // Foo(p1_type p1, ..., pk_type pk) { ... } 1312 // 1313 // When you write Foo(v1, ..., vk), the compiler infers the types of 1314 // the parameters v1, ..., and vk for you. If you are not happy with 1315 // the result of the type inference, you can specify the types by 1316 // explicitly instantiating the template, as in Foo<long, bool>(5, 1317 // false). As said earlier, you don't get to (or need to) specify 1318 // 'arg_type' as that's determined by the context in which the matcher 1319 // is used. You can assign the result of expression Foo(p1, ..., pk) 1320 // to a variable of type FooMatcherPk<p1_type, ..., pk_type>. This 1321 // can be useful when composing matchers. 1322 // 1323 // While you can instantiate a matcher template with reference types, 1324 // passing the parameters by pointer usually makes your code more 1325 // readable. If, however, you still want to pass a parameter by 1326 // reference, be aware that in the failure message generated by the 1327 // matcher you will see the value of the referenced object but not its 1328 // address. 1329 // 1330 // Explaining Match Results 1331 // ======================== 1332 // 1333 // Sometimes the matcher description alone isn't enough to explain why 1334 // the match has failed or succeeded. For example, when expecting a 1335 // long string, it can be very helpful to also print the diff between 1336 // the expected string and the actual one. To achieve that, you can 1337 // optionally stream additional information to a special variable 1338 // named result_listener, whose type is a pointer to class 1339 // MatchResultListener: 1340 // 1341 // MATCHER_P(EqualsLongString, str, "") { 1342 // if (arg == str) return true; 1343 // 1344 // *result_listener << "the difference: " 1345 /// << DiffStrings(str, arg); 1346 // return false; 1347 // } 1348 // 1349 // Overloading Matchers 1350 // ==================== 1351 // 1352 // You can overload matchers with different numbers of parameters: 1353 // 1354 // MATCHER_P(Blah, a, description_string1) { ... } 1355 // MATCHER_P2(Blah, a, b, description_string2) { ... } 1356 // 1357 // Caveats 1358 // ======= 1359 // 1360 // When defining a new matcher, you should also consider implementing 1361 // MatcherInterface or using MakePolymorphicMatcher(). These 1362 // approaches require more work than the MATCHER* macros, but also 1363 // give you more control on the types of the value being matched and 1364 // the matcher parameters, which may leads to better compiler error 1365 // messages when the matcher is used wrong. They also allow 1366 // overloading matchers based on parameter types (as opposed to just 1367 // based on the number of parameters). 1368 // 1369 // MATCHER*() can only be used in a namespace scope. The reason is 1370 // that C++ doesn't yet allow function-local types to be used to 1371 // instantiate templates. The up-coming C++0x standard will fix this. 1372 // Once that's done, we'll consider supporting using MATCHER*() inside 1373 // a function. 1374 // 1375 // More Information 1376 // ================ 1377 // 1378 // To learn more about using these macros, please search for 'MATCHER' 1379 // on http://code.google.com/p/googlemock/wiki/CookBook. 1380 1381 #define MATCHER(name, description)\ 1382 class name##Matcher {\ 1383 public:\ 1384 template <typename arg_type>\ 1385 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1386 public:\ 1387 gmock_Impl()\ 1388 {}\ 1389 virtual bool MatchAndExplain(\ 1390 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1391 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1392 *gmock_os << FormatDescription(false);\ 1393 }\ 1394 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1395 *gmock_os << FormatDescription(true);\ 1396 }\ 1397 private:\ 1398 ::testing::internal::string FormatDescription(bool negation) const {\ 1399 const ::testing::internal::string gmock_description = (description);\ 1400 if (!gmock_description.empty())\ 1401 return gmock_description;\ 1402 return ::testing::internal::FormatMatcherDescription(\ 1403 negation, #name, \ 1404 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1405 ::testing::tuple<>()));\ 1406 }\ 1407 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1408 };\ 1409 template <typename arg_type>\ 1410 operator ::testing::Matcher<arg_type>() const {\ 1411 return ::testing::Matcher<arg_type>(\ 1412 new gmock_Impl<arg_type>());\ 1413 }\ 1414 name##Matcher() {\ 1415 }\ 1416 private:\ 1417 GTEST_DISALLOW_ASSIGN_(name##Matcher);\ 1418 };\ 1419 inline name##Matcher name() {\ 1420 return name##Matcher();\ 1421 }\ 1422 template <typename arg_type>\ 1423 bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\ 1424 arg_type arg, \ 1425 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1426 const 1427 1428 #define MATCHER_P(name, p0, description)\ 1429 template <typename p0##_type>\ 1430 class name##MatcherP {\ 1431 public:\ 1432 template <typename arg_type>\ 1433 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1434 public:\ 1435 explicit gmock_Impl(p0##_type gmock_p0)\ 1436 : p0(gmock_p0) {}\ 1437 virtual bool MatchAndExplain(\ 1438 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1439 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1440 *gmock_os << FormatDescription(false);\ 1441 }\ 1442 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1443 *gmock_os << FormatDescription(true);\ 1444 }\ 1445 p0##_type p0;\ 1446 private:\ 1447 ::testing::internal::string FormatDescription(bool negation) const {\ 1448 const ::testing::internal::string gmock_description = (description);\ 1449 if (!gmock_description.empty())\ 1450 return gmock_description;\ 1451 return ::testing::internal::FormatMatcherDescription(\ 1452 negation, #name, \ 1453 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1454 ::testing::tuple<p0##_type>(p0)));\ 1455 }\ 1456 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1457 };\ 1458 template <typename arg_type>\ 1459 operator ::testing::Matcher<arg_type>() const {\ 1460 return ::testing::Matcher<arg_type>(\ 1461 new gmock_Impl<arg_type>(p0));\ 1462 }\ 1463 explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\ 1464 }\ 1465 p0##_type p0;\ 1466 private:\ 1467 GTEST_DISALLOW_ASSIGN_(name##MatcherP);\ 1468 };\ 1469 template <typename p0##_type>\ 1470 inline name##MatcherP<p0##_type> name(p0##_type p0) {\ 1471 return name##MatcherP<p0##_type>(p0);\ 1472 }\ 1473 template <typename p0##_type>\ 1474 template <typename arg_type>\ 1475 bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1476 arg_type arg, \ 1477 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1478 const 1479 1480 #define MATCHER_P2(name, p0, p1, description)\ 1481 template <typename p0##_type, typename p1##_type>\ 1482 class name##MatcherP2 {\ 1483 public:\ 1484 template <typename arg_type>\ 1485 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1486 public:\ 1487 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\ 1488 : p0(gmock_p0), p1(gmock_p1) {}\ 1489 virtual bool MatchAndExplain(\ 1490 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1491 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1492 *gmock_os << FormatDescription(false);\ 1493 }\ 1494 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1495 *gmock_os << FormatDescription(true);\ 1496 }\ 1497 p0##_type p0;\ 1498 p1##_type p1;\ 1499 private:\ 1500 ::testing::internal::string FormatDescription(bool negation) const {\ 1501 const ::testing::internal::string gmock_description = (description);\ 1502 if (!gmock_description.empty())\ 1503 return gmock_description;\ 1504 return ::testing::internal::FormatMatcherDescription(\ 1505 negation, #name, \ 1506 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1507 ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\ 1508 }\ 1509 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1510 };\ 1511 template <typename arg_type>\ 1512 operator ::testing::Matcher<arg_type>() const {\ 1513 return ::testing::Matcher<arg_type>(\ 1514 new gmock_Impl<arg_type>(p0, p1));\ 1515 }\ 1516 name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \ 1517 p1(gmock_p1) {\ 1518 }\ 1519 p0##_type p0;\ 1520 p1##_type p1;\ 1521 private:\ 1522 GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\ 1523 };\ 1524 template <typename p0##_type, typename p1##_type>\ 1525 inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \ 1526 p1##_type p1) {\ 1527 return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\ 1528 }\ 1529 template <typename p0##_type, typename p1##_type>\ 1530 template <typename arg_type>\ 1531 bool name##MatcherP2<p0##_type, \ 1532 p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1533 arg_type arg, \ 1534 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1535 const 1536 1537 #define MATCHER_P3(name, p0, p1, p2, description)\ 1538 template <typename p0##_type, typename p1##_type, typename p2##_type>\ 1539 class name##MatcherP3 {\ 1540 public:\ 1541 template <typename arg_type>\ 1542 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1543 public:\ 1544 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\ 1545 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\ 1546 virtual bool MatchAndExplain(\ 1547 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1548 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1549 *gmock_os << FormatDescription(false);\ 1550 }\ 1551 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1552 *gmock_os << FormatDescription(true);\ 1553 }\ 1554 p0##_type p0;\ 1555 p1##_type p1;\ 1556 p2##_type p2;\ 1557 private:\ 1558 ::testing::internal::string FormatDescription(bool negation) const {\ 1559 const ::testing::internal::string gmock_description = (description);\ 1560 if (!gmock_description.empty())\ 1561 return gmock_description;\ 1562 return ::testing::internal::FormatMatcherDescription(\ 1563 negation, #name, \ 1564 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1565 ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \ 1566 p2)));\ 1567 }\ 1568 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1569 };\ 1570 template <typename arg_type>\ 1571 operator ::testing::Matcher<arg_type>() const {\ 1572 return ::testing::Matcher<arg_type>(\ 1573 new gmock_Impl<arg_type>(p0, p1, p2));\ 1574 }\ 1575 name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \ 1576 p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\ 1577 }\ 1578 p0##_type p0;\ 1579 p1##_type p1;\ 1580 p2##_type p2;\ 1581 private:\ 1582 GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\ 1583 };\ 1584 template <typename p0##_type, typename p1##_type, typename p2##_type>\ 1585 inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \ 1586 p1##_type p1, p2##_type p2) {\ 1587 return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\ 1588 }\ 1589 template <typename p0##_type, typename p1##_type, typename p2##_type>\ 1590 template <typename arg_type>\ 1591 bool name##MatcherP3<p0##_type, p1##_type, \ 1592 p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1593 arg_type arg, \ 1594 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1595 const 1596 1597 #define MATCHER_P4(name, p0, p1, p2, p3, description)\ 1598 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1599 typename p3##_type>\ 1600 class name##MatcherP4 {\ 1601 public:\ 1602 template <typename arg_type>\ 1603 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1604 public:\ 1605 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1606 p3##_type gmock_p3)\ 1607 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\ 1608 virtual bool MatchAndExplain(\ 1609 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1610 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1611 *gmock_os << FormatDescription(false);\ 1612 }\ 1613 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1614 *gmock_os << FormatDescription(true);\ 1615 }\ 1616 p0##_type p0;\ 1617 p1##_type p1;\ 1618 p2##_type p2;\ 1619 p3##_type p3;\ 1620 private:\ 1621 ::testing::internal::string FormatDescription(bool negation) const {\ 1622 const ::testing::internal::string gmock_description = (description);\ 1623 if (!gmock_description.empty())\ 1624 return gmock_description;\ 1625 return ::testing::internal::FormatMatcherDescription(\ 1626 negation, #name, \ 1627 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1628 ::testing::tuple<p0##_type, p1##_type, p2##_type, \ 1629 p3##_type>(p0, p1, p2, p3)));\ 1630 }\ 1631 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1632 };\ 1633 template <typename arg_type>\ 1634 operator ::testing::Matcher<arg_type>() const {\ 1635 return ::testing::Matcher<arg_type>(\ 1636 new gmock_Impl<arg_type>(p0, p1, p2, p3));\ 1637 }\ 1638 name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \ 1639 p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \ 1640 p2(gmock_p2), p3(gmock_p3) {\ 1641 }\ 1642 p0##_type p0;\ 1643 p1##_type p1;\ 1644 p2##_type p2;\ 1645 p3##_type p3;\ 1646 private:\ 1647 GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\ 1648 };\ 1649 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1650 typename p3##_type>\ 1651 inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \ 1652 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ 1653 p3##_type p3) {\ 1654 return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \ 1655 p1, p2, p3);\ 1656 }\ 1657 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1658 typename p3##_type>\ 1659 template <typename arg_type>\ 1660 bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \ 1661 p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1662 arg_type arg, \ 1663 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1664 const 1665 1666 #define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\ 1667 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1668 typename p3##_type, typename p4##_type>\ 1669 class name##MatcherP5 {\ 1670 public:\ 1671 template <typename arg_type>\ 1672 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1673 public:\ 1674 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1675 p3##_type gmock_p3, p4##_type gmock_p4)\ 1676 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ 1677 p4(gmock_p4) {}\ 1678 virtual bool MatchAndExplain(\ 1679 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1680 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1681 *gmock_os << FormatDescription(false);\ 1682 }\ 1683 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1684 *gmock_os << FormatDescription(true);\ 1685 }\ 1686 p0##_type p0;\ 1687 p1##_type p1;\ 1688 p2##_type p2;\ 1689 p3##_type p3;\ 1690 p4##_type p4;\ 1691 private:\ 1692 ::testing::internal::string FormatDescription(bool negation) const {\ 1693 const ::testing::internal::string gmock_description = (description);\ 1694 if (!gmock_description.empty())\ 1695 return gmock_description;\ 1696 return ::testing::internal::FormatMatcherDescription(\ 1697 negation, #name, \ 1698 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1699 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ 1700 p4##_type>(p0, p1, p2, p3, p4)));\ 1701 }\ 1702 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1703 };\ 1704 template <typename arg_type>\ 1705 operator ::testing::Matcher<arg_type>() const {\ 1706 return ::testing::Matcher<arg_type>(\ 1707 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\ 1708 }\ 1709 name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \ 1710 p2##_type gmock_p2, p3##_type gmock_p3, \ 1711 p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ 1712 p3(gmock_p3), p4(gmock_p4) {\ 1713 }\ 1714 p0##_type p0;\ 1715 p1##_type p1;\ 1716 p2##_type p2;\ 1717 p3##_type p3;\ 1718 p4##_type p4;\ 1719 private:\ 1720 GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\ 1721 };\ 1722 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1723 typename p3##_type, typename p4##_type>\ 1724 inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \ 1725 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 1726 p4##_type p4) {\ 1727 return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \ 1728 p4##_type>(p0, p1, p2, p3, p4);\ 1729 }\ 1730 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1731 typename p3##_type, typename p4##_type>\ 1732 template <typename arg_type>\ 1733 bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \ 1734 p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1735 arg_type arg, \ 1736 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1737 const 1738 1739 #define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\ 1740 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1741 typename p3##_type, typename p4##_type, typename p5##_type>\ 1742 class name##MatcherP6 {\ 1743 public:\ 1744 template <typename arg_type>\ 1745 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1746 public:\ 1747 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1748 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\ 1749 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ 1750 p4(gmock_p4), p5(gmock_p5) {}\ 1751 virtual bool MatchAndExplain(\ 1752 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1753 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1754 *gmock_os << FormatDescription(false);\ 1755 }\ 1756 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1757 *gmock_os << FormatDescription(true);\ 1758 }\ 1759 p0##_type p0;\ 1760 p1##_type p1;\ 1761 p2##_type p2;\ 1762 p3##_type p3;\ 1763 p4##_type p4;\ 1764 p5##_type p5;\ 1765 private:\ 1766 ::testing::internal::string FormatDescription(bool negation) const {\ 1767 const ::testing::internal::string gmock_description = (description);\ 1768 if (!gmock_description.empty())\ 1769 return gmock_description;\ 1770 return ::testing::internal::FormatMatcherDescription(\ 1771 negation, #name, \ 1772 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1773 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ 1774 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\ 1775 }\ 1776 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1777 };\ 1778 template <typename arg_type>\ 1779 operator ::testing::Matcher<arg_type>() const {\ 1780 return ::testing::Matcher<arg_type>(\ 1781 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\ 1782 }\ 1783 name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \ 1784 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 1785 p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ 1786 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\ 1787 }\ 1788 p0##_type p0;\ 1789 p1##_type p1;\ 1790 p2##_type p2;\ 1791 p3##_type p3;\ 1792 p4##_type p4;\ 1793 p5##_type p5;\ 1794 private:\ 1795 GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\ 1796 };\ 1797 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1798 typename p3##_type, typename p4##_type, typename p5##_type>\ 1799 inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \ 1800 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ 1801 p3##_type p3, p4##_type p4, p5##_type p5) {\ 1802 return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \ 1803 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\ 1804 }\ 1805 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1806 typename p3##_type, typename p4##_type, typename p5##_type>\ 1807 template <typename arg_type>\ 1808 bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1809 p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1810 arg_type arg, \ 1811 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1812 const 1813 1814 #define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\ 1815 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1816 typename p3##_type, typename p4##_type, typename p5##_type, \ 1817 typename p6##_type>\ 1818 class name##MatcherP7 {\ 1819 public:\ 1820 template <typename arg_type>\ 1821 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1822 public:\ 1823 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1824 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1825 p6##_type gmock_p6)\ 1826 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ 1827 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\ 1828 virtual bool MatchAndExplain(\ 1829 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1830 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1831 *gmock_os << FormatDescription(false);\ 1832 }\ 1833 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1834 *gmock_os << FormatDescription(true);\ 1835 }\ 1836 p0##_type p0;\ 1837 p1##_type p1;\ 1838 p2##_type p2;\ 1839 p3##_type p3;\ 1840 p4##_type p4;\ 1841 p5##_type p5;\ 1842 p6##_type p6;\ 1843 private:\ 1844 ::testing::internal::string FormatDescription(bool negation) const {\ 1845 const ::testing::internal::string gmock_description = (description);\ 1846 if (!gmock_description.empty())\ 1847 return gmock_description;\ 1848 return ::testing::internal::FormatMatcherDescription(\ 1849 negation, #name, \ 1850 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1851 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ 1852 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \ 1853 p6)));\ 1854 }\ 1855 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1856 };\ 1857 template <typename arg_type>\ 1858 operator ::testing::Matcher<arg_type>() const {\ 1859 return ::testing::Matcher<arg_type>(\ 1860 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\ 1861 }\ 1862 name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \ 1863 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 1864 p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \ 1865 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \ 1866 p6(gmock_p6) {\ 1867 }\ 1868 p0##_type p0;\ 1869 p1##_type p1;\ 1870 p2##_type p2;\ 1871 p3##_type p3;\ 1872 p4##_type p4;\ 1873 p5##_type p5;\ 1874 p6##_type p6;\ 1875 private:\ 1876 GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\ 1877 };\ 1878 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1879 typename p3##_type, typename p4##_type, typename p5##_type, \ 1880 typename p6##_type>\ 1881 inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \ 1882 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \ 1883 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ 1884 p6##_type p6) {\ 1885 return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \ 1886 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\ 1887 }\ 1888 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1889 typename p3##_type, typename p4##_type, typename p5##_type, \ 1890 typename p6##_type>\ 1891 template <typename arg_type>\ 1892 bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1893 p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1894 arg_type arg, \ 1895 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1896 const 1897 1898 #define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\ 1899 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1900 typename p3##_type, typename p4##_type, typename p5##_type, \ 1901 typename p6##_type, typename p7##_type>\ 1902 class name##MatcherP8 {\ 1903 public:\ 1904 template <typename arg_type>\ 1905 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1906 public:\ 1907 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1908 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1909 p6##_type gmock_p6, p7##_type gmock_p7)\ 1910 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ 1911 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\ 1912 virtual bool MatchAndExplain(\ 1913 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 1914 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 1915 *gmock_os << FormatDescription(false);\ 1916 }\ 1917 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 1918 *gmock_os << FormatDescription(true);\ 1919 }\ 1920 p0##_type p0;\ 1921 p1##_type p1;\ 1922 p2##_type p2;\ 1923 p3##_type p3;\ 1924 p4##_type p4;\ 1925 p5##_type p5;\ 1926 p6##_type p6;\ 1927 p7##_type p7;\ 1928 private:\ 1929 ::testing::internal::string FormatDescription(bool negation) const {\ 1930 const ::testing::internal::string gmock_description = (description);\ 1931 if (!gmock_description.empty())\ 1932 return gmock_description;\ 1933 return ::testing::internal::FormatMatcherDescription(\ 1934 negation, #name, \ 1935 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 1936 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ 1937 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \ 1938 p3, p4, p5, p6, p7)));\ 1939 }\ 1940 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1941 };\ 1942 template <typename arg_type>\ 1943 operator ::testing::Matcher<arg_type>() const {\ 1944 return ::testing::Matcher<arg_type>(\ 1945 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\ 1946 }\ 1947 name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \ 1948 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 1949 p5##_type gmock_p5, p6##_type gmock_p6, \ 1950 p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ 1951 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ 1952 p7(gmock_p7) {\ 1953 }\ 1954 p0##_type p0;\ 1955 p1##_type p1;\ 1956 p2##_type p2;\ 1957 p3##_type p3;\ 1958 p4##_type p4;\ 1959 p5##_type p5;\ 1960 p6##_type p6;\ 1961 p7##_type p7;\ 1962 private:\ 1963 GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\ 1964 };\ 1965 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1966 typename p3##_type, typename p4##_type, typename p5##_type, \ 1967 typename p6##_type, typename p7##_type>\ 1968 inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \ 1969 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \ 1970 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ 1971 p6##_type p6, p7##_type p7) {\ 1972 return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \ 1973 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \ 1974 p6, p7);\ 1975 }\ 1976 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1977 typename p3##_type, typename p4##_type, typename p5##_type, \ 1978 typename p6##_type, typename p7##_type>\ 1979 template <typename arg_type>\ 1980 bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1981 p5##_type, p6##_type, \ 1982 p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 1983 arg_type arg, \ 1984 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 1985 const 1986 1987 #define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\ 1988 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1989 typename p3##_type, typename p4##_type, typename p5##_type, \ 1990 typename p6##_type, typename p7##_type, typename p8##_type>\ 1991 class name##MatcherP9 {\ 1992 public:\ 1993 template <typename arg_type>\ 1994 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 1995 public:\ 1996 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1997 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1998 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\ 1999 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ 2000 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ 2001 p8(gmock_p8) {}\ 2002 virtual bool MatchAndExplain(\ 2003 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 2004 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 2005 *gmock_os << FormatDescription(false);\ 2006 }\ 2007 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 2008 *gmock_os << FormatDescription(true);\ 2009 }\ 2010 p0##_type p0;\ 2011 p1##_type p1;\ 2012 p2##_type p2;\ 2013 p3##_type p3;\ 2014 p4##_type p4;\ 2015 p5##_type p5;\ 2016 p6##_type p6;\ 2017 p7##_type p7;\ 2018 p8##_type p8;\ 2019 private:\ 2020 ::testing::internal::string FormatDescription(bool negation) const {\ 2021 const ::testing::internal::string gmock_description = (description);\ 2022 if (!gmock_description.empty())\ 2023 return gmock_description;\ 2024 return ::testing::internal::FormatMatcherDescription(\ 2025 negation, #name, \ 2026 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 2027 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ 2028 p4##_type, p5##_type, p6##_type, p7##_type, \ 2029 p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\ 2030 }\ 2031 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 2032 };\ 2033 template <typename arg_type>\ 2034 operator ::testing::Matcher<arg_type>() const {\ 2035 return ::testing::Matcher<arg_type>(\ 2036 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\ 2037 }\ 2038 name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \ 2039 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 2040 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ 2041 p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ 2042 p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ 2043 p8(gmock_p8) {\ 2044 }\ 2045 p0##_type p0;\ 2046 p1##_type p1;\ 2047 p2##_type p2;\ 2048 p3##_type p3;\ 2049 p4##_type p4;\ 2050 p5##_type p5;\ 2051 p6##_type p6;\ 2052 p7##_type p7;\ 2053 p8##_type p8;\ 2054 private:\ 2055 GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\ 2056 };\ 2057 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2058 typename p3##_type, typename p4##_type, typename p5##_type, \ 2059 typename p6##_type, typename p7##_type, typename p8##_type>\ 2060 inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \ 2061 p4##_type, p5##_type, p6##_type, p7##_type, \ 2062 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 2063 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ 2064 p8##_type p8) {\ 2065 return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \ 2066 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \ 2067 p3, p4, p5, p6, p7, p8);\ 2068 }\ 2069 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2070 typename p3##_type, typename p4##_type, typename p5##_type, \ 2071 typename p6##_type, typename p7##_type, typename p8##_type>\ 2072 template <typename arg_type>\ 2073 bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 2074 p5##_type, p6##_type, p7##_type, \ 2075 p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 2076 arg_type arg, \ 2077 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 2078 const 2079 2080 #define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\ 2081 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2082 typename p3##_type, typename p4##_type, typename p5##_type, \ 2083 typename p6##_type, typename p7##_type, typename p8##_type, \ 2084 typename p9##_type>\ 2085 class name##MatcherP10 {\ 2086 public:\ 2087 template <typename arg_type>\ 2088 class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\ 2089 public:\ 2090 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 2091 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 2092 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ 2093 p9##_type gmock_p9)\ 2094 : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \ 2095 p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ 2096 p8(gmock_p8), p9(gmock_p9) {}\ 2097 virtual bool MatchAndExplain(\ 2098 arg_type arg, ::testing::MatchResultListener* result_listener) const;\ 2099 virtual void DescribeTo(::std::ostream* gmock_os) const {\ 2100 *gmock_os << FormatDescription(false);\ 2101 }\ 2102 virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ 2103 *gmock_os << FormatDescription(true);\ 2104 }\ 2105 p0##_type p0;\ 2106 p1##_type p1;\ 2107 p2##_type p2;\ 2108 p3##_type p3;\ 2109 p4##_type p4;\ 2110 p5##_type p5;\ 2111 p6##_type p6;\ 2112 p7##_type p7;\ 2113 p8##_type p8;\ 2114 p9##_type p9;\ 2115 private:\ 2116 ::testing::internal::string FormatDescription(bool negation) const {\ 2117 const ::testing::internal::string gmock_description = (description);\ 2118 if (!gmock_description.empty())\ 2119 return gmock_description;\ 2120 return ::testing::internal::FormatMatcherDescription(\ 2121 negation, #name, \ 2122 ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ 2123 ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \ 2124 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ 2125 p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\ 2126 }\ 2127 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 2128 };\ 2129 template <typename arg_type>\ 2130 operator ::testing::Matcher<arg_type>() const {\ 2131 return ::testing::Matcher<arg_type>(\ 2132 new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\ 2133 }\ 2134 name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \ 2135 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 2136 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ 2137 p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \ 2138 p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ 2139 p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\ 2140 }\ 2141 p0##_type p0;\ 2142 p1##_type p1;\ 2143 p2##_type p2;\ 2144 p3##_type p3;\ 2145 p4##_type p4;\ 2146 p5##_type p5;\ 2147 p6##_type p6;\ 2148 p7##_type p7;\ 2149 p8##_type p8;\ 2150 p9##_type p9;\ 2151 private:\ 2152 GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\ 2153 };\ 2154 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2155 typename p3##_type, typename p4##_type, typename p5##_type, \ 2156 typename p6##_type, typename p7##_type, typename p8##_type, \ 2157 typename p9##_type>\ 2158 inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \ 2159 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ 2160 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 2161 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ 2162 p9##_type p9) {\ 2163 return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \ 2164 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \ 2165 p1, p2, p3, p4, p5, p6, p7, p8, p9);\ 2166 }\ 2167 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2168 typename p3##_type, typename p4##_type, typename p5##_type, \ 2169 typename p6##_type, typename p7##_type, typename p8##_type, \ 2170 typename p9##_type>\ 2171 template <typename arg_type>\ 2172 bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \ 2173 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ 2174 p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\ 2175 arg_type arg, \ 2176 ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ 2177 const 2178 2179 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ 2180
