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 47namespace testing { 48namespace 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 65template <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> 68class TupleFields; 69 70// This generic version is used when there are 10 selectors. 71template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6, 72 int k7, int k8, int k9> 73class 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 89template <class Tuple> 90class 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 98template <class Tuple, int k0> 99class 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 107template <class Tuple, int k0, int k1> 108class 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 117template <class Tuple, int k0, int k1, int k2> 118class 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 127template <class Tuple, int k0, int k1, int k2, int k3> 128class 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 138template <class Tuple, int k0, int k1, int k2, int k3, int k4> 139class 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 149template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5> 150class 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 162template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6> 163class 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 175template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6, 176 int k7> 177class 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 190template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6, 191 int k7, int k8> 192class 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. 208template <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> 211class 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 278template <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> 281class 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. 304template <typename M1> 305struct AllOfResult1 { 306 typedef M1 type; 307}; 308 309template <typename M1, typename M2> 310struct AllOfResult2 { 311 typedef BothOfMatcher< 312 typename AllOfResult1<M1>::type, 313 typename AllOfResult1<M2>::type 314 > type; 315}; 316 317template <typename M1, typename M2, typename M3> 318struct AllOfResult3 { 319 typedef BothOfMatcher< 320 typename AllOfResult1<M1>::type, 321 typename AllOfResult2<M2, M3>::type 322 > type; 323}; 324 325template <typename M1, typename M2, typename M3, typename M4> 326struct AllOfResult4 { 327 typedef BothOfMatcher< 328 typename AllOfResult2<M1, M2>::type, 329 typename AllOfResult2<M3, M4>::type 330 > type; 331}; 332 333template <typename M1, typename M2, typename M3, typename M4, typename M5> 334struct AllOfResult5 { 335 typedef BothOfMatcher< 336 typename AllOfResult2<M1, M2>::type, 337 typename AllOfResult3<M3, M4, M5>::type 338 > type; 339}; 340 341template <typename M1, typename M2, typename M3, typename M4, typename M5, 342 typename M6> 343struct AllOfResult6 { 344 typedef BothOfMatcher< 345 typename AllOfResult3<M1, M2, M3>::type, 346 typename AllOfResult3<M4, M5, M6>::type 347 > type; 348}; 349 350template <typename M1, typename M2, typename M3, typename M4, typename M5, 351 typename M6, typename M7> 352struct AllOfResult7 { 353 typedef BothOfMatcher< 354 typename AllOfResult3<M1, M2, M3>::type, 355 typename AllOfResult4<M4, M5, M6, M7>::type 356 > type; 357}; 358 359template <typename M1, typename M2, typename M3, typename M4, typename M5, 360 typename M6, typename M7, typename M8> 361struct AllOfResult8 { 362 typedef BothOfMatcher< 363 typename AllOfResult4<M1, M2, M3, M4>::type, 364 typename AllOfResult4<M5, M6, M7, M8>::type 365 > type; 366}; 367 368template <typename M1, typename M2, typename M3, typename M4, typename M5, 369 typename M6, typename M7, typename M8, typename M9> 370struct 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 377template <typename M1, typename M2, typename M3, typename M4, typename M5, 378 typename M6, typename M7, typename M8, typename M9, typename M10> 379struct 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. 392template <typename M1> 393struct AnyOfResult1 { 394 typedef M1 type; 395}; 396 397template <typename M1, typename M2> 398struct AnyOfResult2 { 399 typedef EitherOfMatcher< 400 typename AnyOfResult1<M1>::type, 401 typename AnyOfResult1<M2>::type 402 > type; 403}; 404 405template <typename M1, typename M2, typename M3> 406struct AnyOfResult3 { 407 typedef EitherOfMatcher< 408 typename AnyOfResult1<M1>::type, 409 typename AnyOfResult2<M2, M3>::type 410 > type; 411}; 412 413template <typename M1, typename M2, typename M3, typename M4> 414struct AnyOfResult4 { 415 typedef EitherOfMatcher< 416 typename AnyOfResult2<M1, M2>::type, 417 typename AnyOfResult2<M3, M4>::type 418 > type; 419}; 420 421template <typename M1, typename M2, typename M3, typename M4, typename M5> 422struct AnyOfResult5 { 423 typedef EitherOfMatcher< 424 typename AnyOfResult2<M1, M2>::type, 425 typename AnyOfResult3<M3, M4, M5>::type 426 > type; 427}; 428 429template <typename M1, typename M2, typename M3, typename M4, typename M5, 430 typename M6> 431struct AnyOfResult6 { 432 typedef EitherOfMatcher< 433 typename AnyOfResult3<M1, M2, M3>::type, 434 typename AnyOfResult3<M4, M5, M6>::type 435 > type; 436}; 437 438template <typename M1, typename M2, typename M3, typename M4, typename M5, 439 typename M6, typename M7> 440struct AnyOfResult7 { 441 typedef EitherOfMatcher< 442 typename AnyOfResult3<M1, M2, M3>::type, 443 typename AnyOfResult4<M4, M5, M6, M7>::type 444 > type; 445}; 446 447template <typename M1, typename M2, typename M3, typename M4, typename M5, 448 typename M6, typename M7, typename M8> 449struct AnyOfResult8 { 450 typedef EitherOfMatcher< 451 typename AnyOfResult4<M1, M2, M3, M4>::type, 452 typename AnyOfResult4<M5, M6, M7, M8>::type 453 > type; 454}; 455 456template <typename M1, typename M2, typename M3, typename M4, typename M5, 457 typename M6, typename M7, typename M8, typename M9> 458struct 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 465template <typename M1, typename M2, typename M3, typename M4, typename M5, 466 typename M6, typename M7, typename M8, typename M9, typename M10> 467struct 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. 479template <typename InnerMatcher> 480inline internal::ArgsMatcher<InnerMatcher> 481Args(const InnerMatcher& matcher) { 482 return internal::ArgsMatcher<InnerMatcher>(matcher); 483} 484 485template <int k1, typename InnerMatcher> 486inline internal::ArgsMatcher<InnerMatcher, k1> 487Args(const InnerMatcher& matcher) { 488 return internal::ArgsMatcher<InnerMatcher, k1>(matcher); 489} 490 491template <int k1, int k2, typename InnerMatcher> 492inline internal::ArgsMatcher<InnerMatcher, k1, k2> 493Args(const InnerMatcher& matcher) { 494 return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher); 495} 496 497template <int k1, int k2, int k3, typename InnerMatcher> 498inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3> 499Args(const InnerMatcher& matcher) { 500 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher); 501} 502 503template <int k1, int k2, int k3, int k4, typename InnerMatcher> 504inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4> 505Args(const InnerMatcher& matcher) { 506 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher); 507} 508 509template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher> 510inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5> 511Args(const InnerMatcher& matcher) { 512 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher); 513} 514 515template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher> 516inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6> 517Args(const InnerMatcher& matcher) { 518 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher); 519} 520 521template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, 522 typename InnerMatcher> 523inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7> 524Args(const InnerMatcher& matcher) { 525 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, 526 k7>(matcher); 527} 528 529template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 530 typename InnerMatcher> 531inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8> 532Args(const InnerMatcher& matcher) { 533 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, 534 k8>(matcher); 535} 536 537template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 538 int k9, typename InnerMatcher> 539inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9> 540Args(const InnerMatcher& matcher) { 541 return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, 542 k9>(matcher); 543} 544 545template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 546 int k9, int k10, typename InnerMatcher> 547inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9, 548 k10> 549Args(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 568inline internal::ElementsAreMatcher< 569 ::testing::tuple<> > 570ElementsAre() { 571 typedef ::testing::tuple<> Args; 572 return internal::ElementsAreMatcher<Args>(Args()); 573} 574 575template <typename T1> 576inline internal::ElementsAreMatcher< 577 ::testing::tuple< 578 typename internal::DecayArray<T1>::type> > 579ElementsAre(const T1& e1) { 580 typedef ::testing::tuple< 581 typename internal::DecayArray<T1>::type> Args; 582 return internal::ElementsAreMatcher<Args>(Args(e1)); 583} 584 585template <typename T1, typename T2> 586inline internal::ElementsAreMatcher< 587 ::testing::tuple< 588 typename internal::DecayArray<T1>::type, 589 typename internal::DecayArray<T2>::type> > 590ElementsAre(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 597template <typename T1, typename T2, typename T3> 598inline internal::ElementsAreMatcher< 599 ::testing::tuple< 600 typename internal::DecayArray<T1>::type, 601 typename internal::DecayArray<T2>::type, 602 typename internal::DecayArray<T3>::type> > 603ElementsAre(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 611template <typename T1, typename T2, typename T3, typename T4> 612inline 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> > 618ElementsAre(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 627template <typename T1, typename T2, typename T3, typename T4, typename T5> 628inline 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> > 635ElementsAre(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 646template <typename T1, typename T2, typename T3, typename T4, typename T5, 647 typename T6> 648inline 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> > 656ElementsAre(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 668template <typename T1, typename T2, typename T3, typename T4, typename T5, 669 typename T6, typename T7> 670inline 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> > 679ElementsAre(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 692template <typename T1, typename T2, typename T3, typename T4, typename T5, 693 typename T6, typename T7, typename T8> 694inline 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> > 704ElementsAre(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 719template <typename T1, typename T2, typename T3, typename T4, typename T5, 720 typename T6, typename T7, typename T8, typename T9> 721inline 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> > 732ElementsAre(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 748template <typename T1, typename T2, typename T3, typename T4, typename T5, 749 typename T6, typename T7, typename T8, typename T9, typename T10> 750inline 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> > 762ElementsAre(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 783inline internal::UnorderedElementsAreMatcher< 784 ::testing::tuple<> > 785UnorderedElementsAre() { 786 typedef ::testing::tuple<> Args; 787 return internal::UnorderedElementsAreMatcher<Args>(Args()); 788} 789 790template <typename T1> 791inline internal::UnorderedElementsAreMatcher< 792 ::testing::tuple< 793 typename internal::DecayArray<T1>::type> > 794UnorderedElementsAre(const T1& e1) { 795 typedef ::testing::tuple< 796 typename internal::DecayArray<T1>::type> Args; 797 return internal::UnorderedElementsAreMatcher<Args>(Args(e1)); 798} 799 800template <typename T1, typename T2> 801inline internal::UnorderedElementsAreMatcher< 802 ::testing::tuple< 803 typename internal::DecayArray<T1>::type, 804 typename internal::DecayArray<T2>::type> > 805UnorderedElementsAre(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 812template <typename T1, typename T2, typename T3> 813inline internal::UnorderedElementsAreMatcher< 814 ::testing::tuple< 815 typename internal::DecayArray<T1>::type, 816 typename internal::DecayArray<T2>::type, 817 typename internal::DecayArray<T3>::type> > 818UnorderedElementsAre(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 826template <typename T1, typename T2, typename T3, typename T4> 827inline 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> > 833UnorderedElementsAre(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 842template <typename T1, typename T2, typename T3, typename T4, typename T5> 843inline 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> > 850UnorderedElementsAre(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 861template <typename T1, typename T2, typename T3, typename T4, typename T5, 862 typename T6> 863inline 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> > 871UnorderedElementsAre(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 884template <typename T1, typename T2, typename T3, typename T4, typename T5, 885 typename T6, typename T7> 886inline 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> > 895UnorderedElementsAre(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 909template <typename T1, typename T2, typename T3, typename T4, typename T5, 910 typename T6, typename T7, typename T8> 911inline 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> > 921UnorderedElementsAre(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 936template <typename T1, typename T2, typename T3, typename T4, typename T5, 937 typename T6, typename T7, typename T8, typename T9> 938inline 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> > 949UnorderedElementsAre(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 965template <typename T1, typename T2, typename T3, typename T4, typename T5, 966 typename T6, typename T7, typename T8, typename T9, typename T10> 967inline 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> > 979UnorderedElementsAre(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 1000template <typename M1, typename M2> 1001inline typename internal::AllOfResult2<M1, M2>::type 1002AllOf(M1 m1, M2 m2) { 1003 return typename internal::AllOfResult2<M1, M2>::type( 1004 m1, 1005 m2); 1006} 1007 1008template <typename M1, typename M2, typename M3> 1009inline typename internal::AllOfResult3<M1, M2, M3>::type 1010AllOf(M1 m1, M2 m2, M3 m3) { 1011 return typename internal::AllOfResult3<M1, M2, M3>::type( 1012 m1, 1013 ::testing::AllOf(m2, m3)); 1014} 1015 1016template <typename M1, typename M2, typename M3, typename M4> 1017inline typename internal::AllOfResult4<M1, M2, M3, M4>::type 1018AllOf(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 1024template <typename M1, typename M2, typename M3, typename M4, typename M5> 1025inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type 1026AllOf(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 1032template <typename M1, typename M2, typename M3, typename M4, typename M5, 1033 typename M6> 1034inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type 1035AllOf(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 1041template <typename M1, typename M2, typename M3, typename M4, typename M5, 1042 typename M6, typename M7> 1043inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type 1044AllOf(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 1050template <typename M1, typename M2, typename M3, typename M4, typename M5, 1051 typename M6, typename M7, typename M8> 1052inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type 1053AllOf(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 1059template <typename M1, typename M2, typename M3, typename M4, typename M5, 1060 typename M6, typename M7, typename M8, typename M9> 1061inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type 1062AllOf(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 1069template <typename M1, typename M2, typename M3, typename M4, typename M5, 1070 typename M6, typename M7, typename M8, typename M9, typename M10> 1071inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9, 1072 M10>::type 1073AllOf(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 1083template <typename M1, typename M2> 1084inline typename internal::AnyOfResult2<M1, M2>::type 1085AnyOf(M1 m1, M2 m2) { 1086 return typename internal::AnyOfResult2<M1, M2>::type( 1087 m1, 1088 m2); 1089} 1090 1091template <typename M1, typename M2, typename M3> 1092inline typename internal::AnyOfResult3<M1, M2, M3>::type 1093AnyOf(M1 m1, M2 m2, M3 m3) { 1094 return typename internal::AnyOfResult3<M1, M2, M3>::type( 1095 m1, 1096 ::testing::AnyOf(m2, m3)); 1097} 1098 1099template <typename M1, typename M2, typename M3, typename M4> 1100inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type 1101AnyOf(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 1107template <typename M1, typename M2, typename M3, typename M4, typename M5> 1108inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type 1109AnyOf(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 1115template <typename M1, typename M2, typename M3, typename M4, typename M5, 1116 typename M6> 1117inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type 1118AnyOf(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 1124template <typename M1, typename M2, typename M3, typename M4, typename M5, 1125 typename M6, typename M7> 1126inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type 1127AnyOf(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 1133template <typename M1, typename M2, typename M3, typename M4, typename M5, 1134 typename M6, typename M7, typename M8> 1135inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type 1136AnyOf(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 1142template <typename M1, typename M2, typename M3, typename M4, typename M5, 1143 typename M6, typename M7, typename M8, typename M9> 1144inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type 1145AnyOf(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 1152template <typename M1, typename M2, typename M3, typename M4, typename M5, 1153 typename M6, typename M7, typename M8, typename M9, typename M10> 1154inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9, 1155 M10>::type 1156AnyOf(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