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