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