1// This file was GENERATED by command: 2// pump.py gmock-generated-actions.h.pump 3// DO NOT EDIT BY HAND!!! 4 5// Copyright 2007, 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 35// Google Mock - a framework for writing C++ mock classes. 36// 37// This file implements some commonly used variadic actions. 38 39// GOOGLETEST_CM0002 DO NOT DELETE 40 41#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 42#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 43 44#include "gmock/gmock-actions.h" 45#include "gmock/internal/gmock-port.h" 46 47namespace testing { 48namespace internal { 49 50// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary 51// function, method, or callback with the unpacked values, where F is 52// a function type that takes N arguments. 53template <typename Result, typename ArgumentTuple> 54class InvokeHelper; 55 56template <typename R> 57class InvokeHelper<R, ::testing::tuple<> > { 58 public: 59 template <typename Function> 60 static R Invoke(Function function, const ::testing::tuple<>&) { 61 return function(); 62 } 63 64 template <class Class, typename MethodPtr> 65 static R InvokeMethod(Class* obj_ptr, 66 MethodPtr method_ptr, 67 const ::testing::tuple<>&) { 68 return (obj_ptr->*method_ptr)(); 69 } 70 71 template <typename CallbackType> 72 static R InvokeCallback(CallbackType* callback, 73 const ::testing::tuple<>&) { 74 return callback->Run(); 75 } 76}; 77 78template <typename R, typename A1> 79class InvokeHelper<R, ::testing::tuple<A1> > { 80 public: 81 template <typename Function> 82 static R Invoke(Function function, const ::testing::tuple<A1>& args) { 83 return function(get<0>(args)); 84 } 85 86 template <class Class, typename MethodPtr> 87 static R InvokeMethod(Class* obj_ptr, 88 MethodPtr method_ptr, 89 const ::testing::tuple<A1>& args) { 90 return (obj_ptr->*method_ptr)(get<0>(args)); 91 } 92 93 template <typename CallbackType> 94 static R InvokeCallback(CallbackType* callback, 95 const ::testing::tuple<A1>& args) { 96 return callback->Run(get<0>(args)); 97 } 98}; 99 100template <typename R, typename A1, typename A2> 101class InvokeHelper<R, ::testing::tuple<A1, A2> > { 102 public: 103 template <typename Function> 104 static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) { 105 return function(get<0>(args), get<1>(args)); 106 } 107 108 template <class Class, typename MethodPtr> 109 static R InvokeMethod(Class* obj_ptr, 110 MethodPtr method_ptr, 111 const ::testing::tuple<A1, A2>& args) { 112 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args)); 113 } 114 115 template <typename CallbackType> 116 static R InvokeCallback(CallbackType* callback, 117 const ::testing::tuple<A1, A2>& args) { 118 return callback->Run(get<0>(args), get<1>(args)); 119 } 120}; 121 122template <typename R, typename A1, typename A2, typename A3> 123class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > { 124 public: 125 template <typename Function> 126 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) { 127 return function(get<0>(args), get<1>(args), get<2>(args)); 128 } 129 130 template <class Class, typename MethodPtr> 131 static R InvokeMethod(Class* obj_ptr, 132 MethodPtr method_ptr, 133 const ::testing::tuple<A1, A2, A3>& args) { 134 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 135 get<2>(args)); 136 } 137 138 template <typename CallbackType> 139 static R InvokeCallback(CallbackType* callback, 140 const ::testing::tuple<A1, A2, A3>& args) { 141 return callback->Run(get<0>(args), get<1>(args), get<2>(args)); 142 } 143}; 144 145template <typename R, typename A1, typename A2, typename A3, typename A4> 146class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > { 147 public: 148 template <typename Function> 149 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, 150 A4>& args) { 151 return function(get<0>(args), get<1>(args), get<2>(args), 152 get<3>(args)); 153 } 154 155 template <class Class, typename MethodPtr> 156 static R InvokeMethod(Class* obj_ptr, 157 MethodPtr method_ptr, 158 const ::testing::tuple<A1, A2, A3, A4>& args) { 159 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 160 get<2>(args), get<3>(args)); 161 } 162 163 template <typename CallbackType> 164 static R InvokeCallback(CallbackType* callback, 165 const ::testing::tuple<A1, A2, A3, A4>& args) { 166 return callback->Run(get<0>(args), get<1>(args), get<2>(args), 167 get<3>(args)); 168 } 169}; 170 171template <typename R, typename A1, typename A2, typename A3, typename A4, 172 typename A5> 173class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > { 174 public: 175 template <typename Function> 176 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, 177 A5>& args) { 178 return function(get<0>(args), get<1>(args), get<2>(args), 179 get<3>(args), get<4>(args)); 180 } 181 182 template <class Class, typename MethodPtr> 183 static R InvokeMethod(Class* obj_ptr, 184 MethodPtr method_ptr, 185 const ::testing::tuple<A1, A2, A3, A4, A5>& args) { 186 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 187 get<2>(args), get<3>(args), get<4>(args)); 188 } 189 190 template <typename CallbackType> 191 static R InvokeCallback(CallbackType* callback, 192 const ::testing::tuple<A1, A2, A3, A4, A5>& args) { 193 return callback->Run(get<0>(args), get<1>(args), get<2>(args), 194 get<3>(args), get<4>(args)); 195 } 196}; 197 198template <typename R, typename A1, typename A2, typename A3, typename A4, 199 typename A5, typename A6> 200class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > { 201 public: 202 template <typename Function> 203 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5, 204 A6>& args) { 205 return function(get<0>(args), get<1>(args), get<2>(args), 206 get<3>(args), get<4>(args), get<5>(args)); 207 } 208 209 template <class Class, typename MethodPtr> 210 static R InvokeMethod(Class* obj_ptr, 211 MethodPtr method_ptr, 212 const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) { 213 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 214 get<2>(args), get<3>(args), get<4>(args), get<5>(args)); 215 } 216 217 // There is no InvokeCallback() for 6-tuples 218}; 219 220template <typename R, typename A1, typename A2, typename A3, typename A4, 221 typename A5, typename A6, typename A7> 222class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > { 223 public: 224 template <typename Function> 225 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5, 226 A6, A7>& args) { 227 return function(get<0>(args), get<1>(args), get<2>(args), 228 get<3>(args), get<4>(args), get<5>(args), get<6>(args)); 229 } 230 231 template <class Class, typename MethodPtr> 232 static R InvokeMethod(Class* obj_ptr, 233 MethodPtr method_ptr, 234 const ::testing::tuple<A1, A2, A3, A4, A5, A6, 235 A7>& args) { 236 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 237 get<2>(args), get<3>(args), get<4>(args), get<5>(args), 238 get<6>(args)); 239 } 240 241 // There is no InvokeCallback() for 7-tuples 242}; 243 244template <typename R, typename A1, typename A2, typename A3, typename A4, 245 typename A5, typename A6, typename A7, typename A8> 246class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > { 247 public: 248 template <typename Function> 249 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5, 250 A6, A7, A8>& args) { 251 return function(get<0>(args), get<1>(args), get<2>(args), 252 get<3>(args), get<4>(args), get<5>(args), get<6>(args), 253 get<7>(args)); 254 } 255 256 template <class Class, typename MethodPtr> 257 static R InvokeMethod(Class* obj_ptr, 258 MethodPtr method_ptr, 259 const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, 260 A8>& args) { 261 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 262 get<2>(args), get<3>(args), get<4>(args), get<5>(args), 263 get<6>(args), get<7>(args)); 264 } 265 266 // There is no InvokeCallback() for 8-tuples 267}; 268 269template <typename R, typename A1, typename A2, typename A3, typename A4, 270 typename A5, typename A6, typename A7, typename A8, typename A9> 271class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > { 272 public: 273 template <typename Function> 274 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5, 275 A6, A7, A8, A9>& args) { 276 return function(get<0>(args), get<1>(args), get<2>(args), 277 get<3>(args), get<4>(args), get<5>(args), get<6>(args), 278 get<7>(args), get<8>(args)); 279 } 280 281 template <class Class, typename MethodPtr> 282 static R InvokeMethod(Class* obj_ptr, 283 MethodPtr method_ptr, 284 const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, 285 A9>& args) { 286 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 287 get<2>(args), get<3>(args), get<4>(args), get<5>(args), 288 get<6>(args), get<7>(args), get<8>(args)); 289 } 290 291 // There is no InvokeCallback() for 9-tuples 292}; 293 294template <typename R, typename A1, typename A2, typename A3, typename A4, 295 typename A5, typename A6, typename A7, typename A8, typename A9, 296 typename A10> 297class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9, 298 A10> > { 299 public: 300 template <typename Function> 301 static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5, 302 A6, A7, A8, A9, A10>& args) { 303 return function(get<0>(args), get<1>(args), get<2>(args), 304 get<3>(args), get<4>(args), get<5>(args), get<6>(args), 305 get<7>(args), get<8>(args), get<9>(args)); 306 } 307 308 template <class Class, typename MethodPtr> 309 static R InvokeMethod(Class* obj_ptr, 310 MethodPtr method_ptr, 311 const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, 312 A9, A10>& args) { 313 return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), 314 get<2>(args), get<3>(args), get<4>(args), get<5>(args), 315 get<6>(args), get<7>(args), get<8>(args), get<9>(args)); 316 } 317 318 // There is no InvokeCallback() for 10-tuples 319}; 320 321// Implements the Invoke(callback) action. 322template <typename CallbackType> 323class InvokeCallbackAction { 324 public: 325 // The c'tor takes ownership of the callback. 326 explicit InvokeCallbackAction(CallbackType* callback) 327 : callback_(callback) { 328 callback->CheckIsRepeatable(); // Makes sure the callback is permanent. 329 } 330 331 // This type conversion operator template allows Invoke(callback) to 332 // be used wherever the callback's type is compatible with that of 333 // the mock function, i.e. if the mock function's arguments can be 334 // implicitly converted to the callback's arguments and the 335 // callback's result can be implicitly converted to the mock 336 // function's result. 337 template <typename Result, typename ArgumentTuple> 338 Result Perform(const ArgumentTuple& args) const { 339 return InvokeHelper<Result, ArgumentTuple>::InvokeCallback( 340 callback_.get(), args); 341 } 342 private: 343 const linked_ptr<CallbackType> callback_; 344}; 345 346// An INTERNAL macro for extracting the type of a tuple field. It's 347// subject to change without notice - DO NOT USE IN USER CODE! 348#define GMOCK_FIELD_(Tuple, N) \ 349 typename ::testing::tuple_element<N, Tuple>::type 350 351// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the 352// type of an n-ary function whose i-th (1-based) argument type is the 353// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple 354// type, and whose return type is Result. For example, 355// SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type 356// is int(bool, long). 357// 358// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args) 359// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. 360// For example, 361// SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select( 362// ::testing::make_tuple(true, 'a', 2.5)) 363// returns tuple (2.5, true). 364// 365// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be 366// in the range [0, 10]. Duplicates are allowed and they don't have 367// to be in an ascending or descending order. 368 369template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 370 int k4, int k5, int k6, int k7, int k8, int k9, int k10> 371class SelectArgs { 372 public: 373 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 374 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 375 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), 376 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), 377 GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9), 378 GMOCK_FIELD_(ArgumentTuple, k10)); 379 typedef typename Function<type>::ArgumentTuple SelectedArgs; 380 static SelectedArgs Select(const ArgumentTuple& args) { 381 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 382 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), 383 get<k8>(args), get<k9>(args), get<k10>(args)); 384 } 385}; 386 387template <typename Result, typename ArgumentTuple> 388class SelectArgs<Result, ArgumentTuple, 389 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { 390 public: 391 typedef Result type(); 392 typedef typename Function<type>::ArgumentTuple SelectedArgs; 393 static SelectedArgs Select(const ArgumentTuple& /* args */) { 394 return SelectedArgs(); 395 } 396}; 397 398template <typename Result, typename ArgumentTuple, int k1> 399class SelectArgs<Result, ArgumentTuple, 400 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { 401 public: 402 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1)); 403 typedef typename Function<type>::ArgumentTuple SelectedArgs; 404 static SelectedArgs Select(const ArgumentTuple& args) { 405 return SelectedArgs(get<k1>(args)); 406 } 407}; 408 409template <typename Result, typename ArgumentTuple, int k1, int k2> 410class SelectArgs<Result, ArgumentTuple, 411 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> { 412 public: 413 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 414 GMOCK_FIELD_(ArgumentTuple, k2)); 415 typedef typename Function<type>::ArgumentTuple SelectedArgs; 416 static SelectedArgs Select(const ArgumentTuple& args) { 417 return SelectedArgs(get<k1>(args), get<k2>(args)); 418 } 419}; 420 421template <typename Result, typename ArgumentTuple, int k1, int k2, int k3> 422class SelectArgs<Result, ArgumentTuple, 423 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> { 424 public: 425 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 426 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3)); 427 typedef typename Function<type>::ArgumentTuple SelectedArgs; 428 static SelectedArgs Select(const ArgumentTuple& args) { 429 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args)); 430 } 431}; 432 433template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 434 int k4> 435class SelectArgs<Result, ArgumentTuple, 436 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> { 437 public: 438 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 439 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 440 GMOCK_FIELD_(ArgumentTuple, k4)); 441 typedef typename Function<type>::ArgumentTuple SelectedArgs; 442 static SelectedArgs Select(const ArgumentTuple& args) { 443 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 444 get<k4>(args)); 445 } 446}; 447 448template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 449 int k4, int k5> 450class SelectArgs<Result, ArgumentTuple, 451 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> { 452 public: 453 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 454 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 455 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5)); 456 typedef typename Function<type>::ArgumentTuple SelectedArgs; 457 static SelectedArgs Select(const ArgumentTuple& args) { 458 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 459 get<k4>(args), get<k5>(args)); 460 } 461}; 462 463template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 464 int k4, int k5, int k6> 465class SelectArgs<Result, ArgumentTuple, 466 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> { 467 public: 468 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 469 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 470 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), 471 GMOCK_FIELD_(ArgumentTuple, k6)); 472 typedef typename Function<type>::ArgumentTuple SelectedArgs; 473 static SelectedArgs Select(const ArgumentTuple& args) { 474 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 475 get<k4>(args), get<k5>(args), get<k6>(args)); 476 } 477}; 478 479template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 480 int k4, int k5, int k6, int k7> 481class SelectArgs<Result, ArgumentTuple, 482 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> { 483 public: 484 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 485 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 486 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), 487 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7)); 488 typedef typename Function<type>::ArgumentTuple SelectedArgs; 489 static SelectedArgs Select(const ArgumentTuple& args) { 490 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 491 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args)); 492 } 493}; 494 495template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 496 int k4, int k5, int k6, int k7, int k8> 497class SelectArgs<Result, ArgumentTuple, 498 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> { 499 public: 500 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 501 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 502 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), 503 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), 504 GMOCK_FIELD_(ArgumentTuple, k8)); 505 typedef typename Function<type>::ArgumentTuple SelectedArgs; 506 static SelectedArgs Select(const ArgumentTuple& args) { 507 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 508 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), 509 get<k8>(args)); 510 } 511}; 512 513template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, 514 int k4, int k5, int k6, int k7, int k8, int k9> 515class SelectArgs<Result, ArgumentTuple, 516 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> { 517 public: 518 typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), 519 GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), 520 GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), 521 GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), 522 GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9)); 523 typedef typename Function<type>::ArgumentTuple SelectedArgs; 524 static SelectedArgs Select(const ArgumentTuple& args) { 525 return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), 526 get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), 527 get<k8>(args), get<k9>(args)); 528 } 529}; 530 531#undef GMOCK_FIELD_ 532 533// Implements the WithArgs action. 534template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1, 535 int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1, 536 int k9 = -1, int k10 = -1> 537class WithArgsAction { 538 public: 539 explicit WithArgsAction(const InnerAction& action) : action_(action) {} 540 541 template <typename F> 542 operator Action<F>() const { return MakeAction(new Impl<F>(action_)); } 543 544 private: 545 template <typename F> 546 class Impl : public ActionInterface<F> { 547 public: 548 typedef typename Function<F>::Result Result; 549 typedef typename Function<F>::ArgumentTuple ArgumentTuple; 550 551 explicit Impl(const InnerAction& action) : action_(action) {} 552 553 virtual Result Perform(const ArgumentTuple& args) { 554 return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4, 555 k5, k6, k7, k8, k9, k10>::Select(args)); 556 } 557 558 private: 559 typedef typename SelectArgs<Result, ArgumentTuple, 560 k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType; 561 562 Action<InnerFunctionType> action_; 563 }; 564 565 const InnerAction action_; 566 567 GTEST_DISALLOW_ASSIGN_(WithArgsAction); 568}; 569 570// A macro from the ACTION* family (defined later in this file) 571// defines an action that can be used in a mock function. Typically, 572// these actions only care about a subset of the arguments of the mock 573// function. For example, if such an action only uses the second 574// argument, it can be used in any mock function that takes >= 2 575// arguments where the type of the second argument is compatible. 576// 577// Therefore, the action implementation must be prepared to take more 578// arguments than it needs. The ExcessiveArg type is used to 579// represent those excessive arguments. In order to keep the compiler 580// error messages tractable, we define it in the testing namespace 581// instead of testing::internal. However, this is an INTERNAL TYPE 582// and subject to change without notice, so a user MUST NOT USE THIS 583// TYPE DIRECTLY. 584struct ExcessiveArg {}; 585 586// A helper class needed for implementing the ACTION* macros. 587template <typename Result, class Impl> 588class ActionHelper { 589 public: 590 static Result Perform(Impl* impl, const ::testing::tuple<>& args) { 591 return impl->template gmock_PerformImpl<>(args, ExcessiveArg(), 592 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 593 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 594 ExcessiveArg()); 595 } 596 597 template <typename A0> 598 static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) { 599 return impl->template gmock_PerformImpl<A0>(args, get<0>(args), 600 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 601 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 602 ExcessiveArg()); 603 } 604 605 template <typename A0, typename A1> 606 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) { 607 return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args), 608 get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 609 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 610 ExcessiveArg()); 611 } 612 613 template <typename A0, typename A1, typename A2> 614 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) { 615 return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args), 616 get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(), 617 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 618 ExcessiveArg()); 619 } 620 621 template <typename A0, typename A1, typename A2, typename A3> 622 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, 623 A3>& args) { 624 return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args), 625 get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(), 626 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 627 ExcessiveArg()); 628 } 629 630 template <typename A0, typename A1, typename A2, typename A3, typename A4> 631 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, 632 A4>& args) { 633 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args, 634 get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), 635 ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 636 ExcessiveArg()); 637 } 638 639 template <typename A0, typename A1, typename A2, typename A3, typename A4, 640 typename A5> 641 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4, 642 A5>& args) { 643 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args, 644 get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), 645 get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), 646 ExcessiveArg()); 647 } 648 649 template <typename A0, typename A1, typename A2, typename A3, typename A4, 650 typename A5, typename A6> 651 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4, 652 A5, A6>& args) { 653 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args, 654 get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), 655 get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(), 656 ExcessiveArg()); 657 } 658 659 template <typename A0, typename A1, typename A2, typename A3, typename A4, 660 typename A5, typename A6, typename A7> 661 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4, 662 A5, A6, A7>& args) { 663 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, 664 A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), 665 get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(), 666 ExcessiveArg()); 667 } 668 669 template <typename A0, typename A1, typename A2, typename A3, typename A4, 670 typename A5, typename A6, typename A7, typename A8> 671 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4, 672 A5, A6, A7, A8>& args) { 673 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, 674 A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), 675 get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), 676 ExcessiveArg()); 677 } 678 679 template <typename A0, typename A1, typename A2, typename A3, typename A4, 680 typename A5, typename A6, typename A7, typename A8, typename A9> 681 static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4, 682 A5, A6, A7, A8, A9>& args) { 683 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8, 684 A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), 685 get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), 686 get<9>(args)); 687 } 688}; 689 690} // namespace internal 691 692// Various overloads for Invoke(). 693 694// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes 695// the selected arguments of the mock function to an_action and 696// performs it. It serves as an adaptor between actions with 697// different argument lists. C++ doesn't support default arguments for 698// function templates, so we have to overload it. 699template <int k1, typename InnerAction> 700inline internal::WithArgsAction<InnerAction, k1> 701WithArgs(const InnerAction& action) { 702 return internal::WithArgsAction<InnerAction, k1>(action); 703} 704 705template <int k1, int k2, typename InnerAction> 706inline internal::WithArgsAction<InnerAction, k1, k2> 707WithArgs(const InnerAction& action) { 708 return internal::WithArgsAction<InnerAction, k1, k2>(action); 709} 710 711template <int k1, int k2, int k3, typename InnerAction> 712inline internal::WithArgsAction<InnerAction, k1, k2, k3> 713WithArgs(const InnerAction& action) { 714 return internal::WithArgsAction<InnerAction, k1, k2, k3>(action); 715} 716 717template <int k1, int k2, int k3, int k4, typename InnerAction> 718inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4> 719WithArgs(const InnerAction& action) { 720 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action); 721} 722 723template <int k1, int k2, int k3, int k4, int k5, typename InnerAction> 724inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5> 725WithArgs(const InnerAction& action) { 726 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action); 727} 728 729template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction> 730inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6> 731WithArgs(const InnerAction& action) { 732 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action); 733} 734 735template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, 736 typename InnerAction> 737inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7> 738WithArgs(const InnerAction& action) { 739 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, 740 k7>(action); 741} 742 743template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 744 typename InnerAction> 745inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8> 746WithArgs(const InnerAction& action) { 747 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, 748 k8>(action); 749} 750 751template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 752 int k9, typename InnerAction> 753inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9> 754WithArgs(const InnerAction& action) { 755 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, 756 k9>(action); 757} 758 759template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, 760 int k9, int k10, typename InnerAction> 761inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, 762 k9, k10> 763WithArgs(const InnerAction& action) { 764 return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, 765 k9, k10>(action); 766} 767 768// Creates an action that does actions a1, a2, ..., sequentially in 769// each invocation. 770template <typename Action1, typename Action2> 771inline internal::DoBothAction<Action1, Action2> 772DoAll(Action1 a1, Action2 a2) { 773 return internal::DoBothAction<Action1, Action2>(a1, a2); 774} 775 776template <typename Action1, typename Action2, typename Action3> 777inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 778 Action3> > 779DoAll(Action1 a1, Action2 a2, Action3 a3) { 780 return DoAll(a1, DoAll(a2, a3)); 781} 782 783template <typename Action1, typename Action2, typename Action3, 784 typename Action4> 785inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 786 internal::DoBothAction<Action3, Action4> > > 787DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) { 788 return DoAll(a1, DoAll(a2, a3, a4)); 789} 790 791template <typename Action1, typename Action2, typename Action3, 792 typename Action4, typename Action5> 793inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 794 internal::DoBothAction<Action3, internal::DoBothAction<Action4, 795 Action5> > > > 796DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) { 797 return DoAll(a1, DoAll(a2, a3, a4, a5)); 798} 799 800template <typename Action1, typename Action2, typename Action3, 801 typename Action4, typename Action5, typename Action6> 802inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 803 internal::DoBothAction<Action3, internal::DoBothAction<Action4, 804 internal::DoBothAction<Action5, Action6> > > > > 805DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) { 806 return DoAll(a1, DoAll(a2, a3, a4, a5, a6)); 807} 808 809template <typename Action1, typename Action2, typename Action3, 810 typename Action4, typename Action5, typename Action6, typename Action7> 811inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 812 internal::DoBothAction<Action3, internal::DoBothAction<Action4, 813 internal::DoBothAction<Action5, internal::DoBothAction<Action6, 814 Action7> > > > > > 815DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, 816 Action7 a7) { 817 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7)); 818} 819 820template <typename Action1, typename Action2, typename Action3, 821 typename Action4, typename Action5, typename Action6, typename Action7, 822 typename Action8> 823inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 824 internal::DoBothAction<Action3, internal::DoBothAction<Action4, 825 internal::DoBothAction<Action5, internal::DoBothAction<Action6, 826 internal::DoBothAction<Action7, Action8> > > > > > > 827DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, 828 Action7 a7, Action8 a8) { 829 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8)); 830} 831 832template <typename Action1, typename Action2, typename Action3, 833 typename Action4, typename Action5, typename Action6, typename Action7, 834 typename Action8, typename Action9> 835inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 836 internal::DoBothAction<Action3, internal::DoBothAction<Action4, 837 internal::DoBothAction<Action5, internal::DoBothAction<Action6, 838 internal::DoBothAction<Action7, internal::DoBothAction<Action8, 839 Action9> > > > > > > > 840DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, 841 Action7 a7, Action8 a8, Action9 a9) { 842 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9)); 843} 844 845template <typename Action1, typename Action2, typename Action3, 846 typename Action4, typename Action5, typename Action6, typename Action7, 847 typename Action8, typename Action9, typename Action10> 848inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, 849 internal::DoBothAction<Action3, internal::DoBothAction<Action4, 850 internal::DoBothAction<Action5, internal::DoBothAction<Action6, 851 internal::DoBothAction<Action7, internal::DoBothAction<Action8, 852 internal::DoBothAction<Action9, Action10> > > > > > > > > 853DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, 854 Action7 a7, Action8 a8, Action9 a9, Action10 a10) { 855 return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10)); 856} 857 858} // namespace testing 859 860// The ACTION* family of macros can be used in a namespace scope to 861// define custom actions easily. The syntax: 862// 863// ACTION(name) { statements; } 864// 865// will define an action with the given name that executes the 866// statements. The value returned by the statements will be used as 867// the return value of the action. Inside the statements, you can 868// refer to the K-th (0-based) argument of the mock function by 869// 'argK', and refer to its type by 'argK_type'. For example: 870// 871// ACTION(IncrementArg1) { 872// arg1_type temp = arg1; 873// return ++(*temp); 874// } 875// 876// allows you to write 877// 878// ...WillOnce(IncrementArg1()); 879// 880// You can also refer to the entire argument tuple and its type by 881// 'args' and 'args_type', and refer to the mock function type and its 882// return type by 'function_type' and 'return_type'. 883// 884// Note that you don't need to specify the types of the mock function 885// arguments. However rest assured that your code is still type-safe: 886// you'll get a compiler error if *arg1 doesn't support the ++ 887// operator, or if the type of ++(*arg1) isn't compatible with the 888// mock function's return type, for example. 889// 890// Sometimes you'll want to parameterize the action. For that you can use 891// another macro: 892// 893// ACTION_P(name, param_name) { statements; } 894// 895// For example: 896// 897// ACTION_P(Add, n) { return arg0 + n; } 898// 899// will allow you to write: 900// 901// ...WillOnce(Add(5)); 902// 903// Note that you don't need to provide the type of the parameter 904// either. If you need to reference the type of a parameter named 905// 'foo', you can write 'foo_type'. For example, in the body of 906// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type 907// of 'n'. 908// 909// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support 910// multi-parameter actions. 911// 912// For the purpose of typing, you can view 913// 914// ACTION_Pk(Foo, p1, ..., pk) { ... } 915// 916// as shorthand for 917// 918// template <typename p1_type, ..., typename pk_type> 919// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } 920// 921// In particular, you can provide the template type arguments 922// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); 923// although usually you can rely on the compiler to infer the types 924// for you automatically. You can assign the result of expression 925// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., 926// pk_type>. This can be useful when composing actions. 927// 928// You can also overload actions with different numbers of parameters: 929// 930// ACTION_P(Plus, a) { ... } 931// ACTION_P2(Plus, a, b) { ... } 932// 933// While it's tempting to always use the ACTION* macros when defining 934// a new action, you should also consider implementing ActionInterface 935// or using MakePolymorphicAction() instead, especially if you need to 936// use the action a lot. While these approaches require more work, 937// they give you more control on the types of the mock function 938// arguments and the action parameters, which in general leads to 939// better compiler error messages that pay off in the long run. They 940// also allow overloading actions based on parameter types (as opposed 941// to just based on the number of parameters). 942// 943// CAVEAT: 944// 945// ACTION*() can only be used in a namespace scope. The reason is 946// that C++ doesn't yet allow function-local types to be used to 947// instantiate templates. The up-coming C++0x standard will fix this. 948// Once that's done, we'll consider supporting using ACTION*() inside 949// a function. 950// 951// MORE INFORMATION: 952// 953// To learn more about using these macros, please search for 'ACTION' 954// on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md 955 956// An internal macro needed for implementing ACTION*(). 957#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ 958 const args_type& args GTEST_ATTRIBUTE_UNUSED_, \ 959 arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \ 960 arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \ 961 arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \ 962 arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \ 963 arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \ 964 arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \ 965 arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \ 966 arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \ 967 arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \ 968 arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_ 969 970// Sometimes you want to give an action explicit template parameters 971// that cannot be inferred from its value parameters. ACTION() and 972// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that 973// and can be viewed as an extension to ACTION() and ACTION_P*(). 974// 975// The syntax: 976// 977// ACTION_TEMPLATE(ActionName, 978// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), 979// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } 980// 981// defines an action template that takes m explicit template 982// parameters and n value parameters. name_i is the name of the i-th 983// template parameter, and kind_i specifies whether it's a typename, 984// an integral constant, or a template. p_i is the name of the i-th 985// value parameter. 986// 987// Example: 988// 989// // DuplicateArg<k, T>(output) converts the k-th argument of the mock 990// // function to type T and copies it to *output. 991// ACTION_TEMPLATE(DuplicateArg, 992// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), 993// AND_1_VALUE_PARAMS(output)) { 994// *output = T(::testing::get<k>(args)); 995// } 996// ... 997// int n; 998// EXPECT_CALL(mock, Foo(_, _)) 999// .WillOnce(DuplicateArg<1, unsigned char>(&n)); 1000// 1001// To create an instance of an action template, write: 1002// 1003// ActionName<t1, ..., t_m>(v1, ..., v_n) 1004// 1005// where the ts are the template arguments and the vs are the value 1006// arguments. The value argument types are inferred by the compiler. 1007// If you want to explicitly specify the value argument types, you can 1008// provide additional template arguments: 1009// 1010// ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) 1011// 1012// where u_i is the desired type of v_i. 1013// 1014// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the 1015// number of value parameters, but not on the number of template 1016// parameters. Without the restriction, the meaning of the following 1017// is unclear: 1018// 1019// OverloadedAction<int, bool>(x); 1020// 1021// Are we using a single-template-parameter action where 'bool' refers 1022// to the type of x, or are we using a two-template-parameter action 1023// where the compiler is asked to infer the type of x? 1024// 1025// Implementation notes: 1026// 1027// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and 1028// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for 1029// implementing ACTION_TEMPLATE. The main trick we use is to create 1030// new macro invocations when expanding a macro. For example, we have 1031// 1032// #define ACTION_TEMPLATE(name, template_params, value_params) 1033// ... GMOCK_INTERNAL_DECL_##template_params ... 1034// 1035// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) 1036// to expand to 1037// 1038// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... 1039// 1040// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the 1041// preprocessor will continue to expand it to 1042// 1043// ... typename T ... 1044// 1045// This technique conforms to the C++ standard and is portable. It 1046// allows us to implement action templates using O(N) code, where N is 1047// the maximum number of template/value parameters supported. Without 1048// using it, we'd have to devote O(N^2) amount of code to implement all 1049// combinations of m and n. 1050 1051// Declares the template parameters. 1052#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 1053#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ 1054 name1) kind0 name0, kind1 name1 1055#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1056 kind2, name2) kind0 name0, kind1 name1, kind2 name2 1057#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1058 kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \ 1059 kind3 name3 1060#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1061 kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \ 1062 kind2 name2, kind3 name3, kind4 name4 1063#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1064 kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \ 1065 kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5 1066#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1067 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 1068 name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ 1069 kind5 name5, kind6 name6 1070#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1071 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 1072 kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \ 1073 kind4 name4, kind5 name5, kind6 name6, kind7 name7 1074#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1075 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 1076 kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \ 1077 kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \ 1078 kind8 name8 1079#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ 1080 name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 1081 name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \ 1082 kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \ 1083 kind6 name6, kind7 name7, kind8 name8, kind9 name9 1084 1085// Lists the template parameters. 1086#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0 1087#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ 1088 name1) name0, name1 1089#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1090 kind2, name2) name0, name1, name2 1091#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1092 kind2, name2, kind3, name3) name0, name1, name2, name3 1093#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1094 kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \ 1095 name4 1096#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1097 kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \ 1098 name2, name3, name4, name5 1099#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1100 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 1101 name6) name0, name1, name2, name3, name4, name5, name6 1102#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1103 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 1104 kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7 1105#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 1106 kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 1107 kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \ 1108 name6, name7, name8 1109#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ 1110 name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 1111 name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \ 1112 name3, name4, name5, name6, name7, name8, name9 1113 1114// Declares the types of value parameters. 1115#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS() 1116#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type 1117#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \ 1118 typename p0##_type, typename p1##_type 1119#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \ 1120 typename p0##_type, typename p1##_type, typename p2##_type 1121#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ 1122 typename p0##_type, typename p1##_type, typename p2##_type, \ 1123 typename p3##_type 1124#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ 1125 typename p0##_type, typename p1##_type, typename p2##_type, \ 1126 typename p3##_type, typename p4##_type 1127#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ 1128 typename p0##_type, typename p1##_type, typename p2##_type, \ 1129 typename p3##_type, typename p4##_type, typename p5##_type 1130#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1131 p6) , typename p0##_type, typename p1##_type, typename p2##_type, \ 1132 typename p3##_type, typename p4##_type, typename p5##_type, \ 1133 typename p6##_type 1134#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1135 p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \ 1136 typename p3##_type, typename p4##_type, typename p5##_type, \ 1137 typename p6##_type, typename p7##_type 1138#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1139 p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \ 1140 typename p3##_type, typename p4##_type, typename p5##_type, \ 1141 typename p6##_type, typename p7##_type, typename p8##_type 1142#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1143 p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \ 1144 typename p2##_type, typename p3##_type, typename p4##_type, \ 1145 typename p5##_type, typename p6##_type, typename p7##_type, \ 1146 typename p8##_type, typename p9##_type 1147 1148// Initializes the value parameters. 1149#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\ 1150 () 1151#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\ 1152 (p0##_type gmock_p0) : p0(::testing::internal::move(gmock_p0)) 1153#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\ 1154 (p0##_type gmock_p0, \ 1155 p1##_type gmock_p1) : p0(::testing::internal::move(gmock_p0)), \ 1156 p1(::testing::internal::move(gmock_p1)) 1157#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\ 1158 (p0##_type gmock_p0, p1##_type gmock_p1, \ 1159 p2##_type gmock_p2) : p0(::testing::internal::move(gmock_p0)), \ 1160 p1(::testing::internal::move(gmock_p1)), \ 1161 p2(::testing::internal::move(gmock_p2)) 1162#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\ 1163 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1164 p3##_type gmock_p3) : p0(::testing::internal::move(gmock_p0)), \ 1165 p1(::testing::internal::move(gmock_p1)), \ 1166 p2(::testing::internal::move(gmock_p2)), \ 1167 p3(::testing::internal::move(gmock_p3)) 1168#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\ 1169 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1170 p3##_type gmock_p3, \ 1171 p4##_type gmock_p4) : p0(::testing::internal::move(gmock_p0)), \ 1172 p1(::testing::internal::move(gmock_p1)), \ 1173 p2(::testing::internal::move(gmock_p2)), \ 1174 p3(::testing::internal::move(gmock_p3)), \ 1175 p4(::testing::internal::move(gmock_p4)) 1176#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\ 1177 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1178 p3##_type gmock_p3, p4##_type gmock_p4, \ 1179 p5##_type gmock_p5) : p0(::testing::internal::move(gmock_p0)), \ 1180 p1(::testing::internal::move(gmock_p1)), \ 1181 p2(::testing::internal::move(gmock_p2)), \ 1182 p3(::testing::internal::move(gmock_p3)), \ 1183 p4(::testing::internal::move(gmock_p4)), \ 1184 p5(::testing::internal::move(gmock_p5)) 1185#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\ 1186 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1187 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1188 p6##_type gmock_p6) : p0(::testing::internal::move(gmock_p0)), \ 1189 p1(::testing::internal::move(gmock_p1)), \ 1190 p2(::testing::internal::move(gmock_p2)), \ 1191 p3(::testing::internal::move(gmock_p3)), \ 1192 p4(::testing::internal::move(gmock_p4)), \ 1193 p5(::testing::internal::move(gmock_p5)), \ 1194 p6(::testing::internal::move(gmock_p6)) 1195#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\ 1196 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1197 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1198 p6##_type gmock_p6, \ 1199 p7##_type gmock_p7) : p0(::testing::internal::move(gmock_p0)), \ 1200 p1(::testing::internal::move(gmock_p1)), \ 1201 p2(::testing::internal::move(gmock_p2)), \ 1202 p3(::testing::internal::move(gmock_p3)), \ 1203 p4(::testing::internal::move(gmock_p4)), \ 1204 p5(::testing::internal::move(gmock_p5)), \ 1205 p6(::testing::internal::move(gmock_p6)), \ 1206 p7(::testing::internal::move(gmock_p7)) 1207#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1208 p7, p8)\ 1209 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1210 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1211 p6##_type gmock_p6, p7##_type gmock_p7, \ 1212 p8##_type gmock_p8) : p0(::testing::internal::move(gmock_p0)), \ 1213 p1(::testing::internal::move(gmock_p1)), \ 1214 p2(::testing::internal::move(gmock_p2)), \ 1215 p3(::testing::internal::move(gmock_p3)), \ 1216 p4(::testing::internal::move(gmock_p4)), \ 1217 p5(::testing::internal::move(gmock_p5)), \ 1218 p6(::testing::internal::move(gmock_p6)), \ 1219 p7(::testing::internal::move(gmock_p7)), \ 1220 p8(::testing::internal::move(gmock_p8)) 1221#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1222 p7, p8, p9)\ 1223 (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1224 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1225 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ 1226 p9##_type gmock_p9) : p0(::testing::internal::move(gmock_p0)), \ 1227 p1(::testing::internal::move(gmock_p1)), \ 1228 p2(::testing::internal::move(gmock_p2)), \ 1229 p3(::testing::internal::move(gmock_p3)), \ 1230 p4(::testing::internal::move(gmock_p4)), \ 1231 p5(::testing::internal::move(gmock_p5)), \ 1232 p6(::testing::internal::move(gmock_p6)), \ 1233 p7(::testing::internal::move(gmock_p7)), \ 1234 p8(::testing::internal::move(gmock_p8)), \ 1235 p9(::testing::internal::move(gmock_p9)) 1236 1237// Declares the fields for storing the value parameters. 1238#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS() 1239#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0; 1240#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \ 1241 p1##_type p1; 1242#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \ 1243 p1##_type p1; p2##_type p2; 1244#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \ 1245 p1##_type p1; p2##_type p2; p3##_type p3; 1246#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ 1247 p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; 1248#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ 1249 p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ 1250 p5##_type p5; 1251#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1252 p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ 1253 p5##_type p5; p6##_type p6; 1254#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1255 p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ 1256 p5##_type p5; p6##_type p6; p7##_type p7; 1257#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1258 p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ 1259 p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; 1260#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1261 p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ 1262 p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \ 1263 p9##_type p9; 1264 1265// Lists the value parameters. 1266#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS() 1267#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0 1268#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1 1269#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2 1270#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3 1271#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \ 1272 p2, p3, p4 1273#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \ 1274 p1, p2, p3, p4, p5 1275#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1276 p6) p0, p1, p2, p3, p4, p5, p6 1277#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1278 p7) p0, p1, p2, p3, p4, p5, p6, p7 1279#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1280 p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8 1281#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1282 p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 1283 1284// Lists the value parameter types. 1285#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS() 1286#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type 1287#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \ 1288 p1##_type 1289#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \ 1290 p1##_type, p2##_type 1291#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ 1292 p0##_type, p1##_type, p2##_type, p3##_type 1293#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ 1294 p0##_type, p1##_type, p2##_type, p3##_type, p4##_type 1295#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ 1296 p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type 1297#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1298 p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ 1299 p6##_type 1300#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1301 p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1302 p5##_type, p6##_type, p7##_type 1303#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1304 p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1305 p5##_type, p6##_type, p7##_type, p8##_type 1306#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1307 p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1308 p5##_type, p6##_type, p7##_type, p8##_type, p9##_type 1309 1310// Declares the value parameters. 1311#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS() 1312#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0 1313#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \ 1314 p1##_type p1 1315#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \ 1316 p1##_type p1, p2##_type p2 1317#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \ 1318 p1##_type p1, p2##_type p2, p3##_type p3 1319#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ 1320 p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4 1321#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ 1322 p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ 1323 p5##_type p5 1324#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 1325 p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ 1326 p5##_type p5, p6##_type p6 1327#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1328 p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ 1329 p5##_type p5, p6##_type p6, p7##_type p7 1330#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1331 p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 1332 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8 1333#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1334 p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 1335 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ 1336 p9##_type p9 1337 1338// The suffix of the class template implementing the action template. 1339#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS() 1340#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P 1341#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 1342#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3 1343#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4 1344#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5 1345#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6 1346#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7 1347#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1348 p7) P8 1349#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1350 p7, p8) P9 1351#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 1352 p7, p8, p9) P10 1353 1354// The name of the class template implementing the action template. 1355#define GMOCK_ACTION_CLASS_(name, value_params)\ 1356 GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) 1357 1358#define ACTION_TEMPLATE(name, template_params, value_params)\ 1359 template <GMOCK_INTERNAL_DECL_##template_params\ 1360 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 1361 class GMOCK_ACTION_CLASS_(name, value_params) {\ 1362 public:\ 1363 explicit GMOCK_ACTION_CLASS_(name, value_params)\ 1364 GMOCK_INTERNAL_INIT_##value_params {}\ 1365 template <typename F>\ 1366 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1367 public:\ 1368 typedef F function_type;\ 1369 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1370 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1371 args_type;\ 1372 explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ 1373 virtual return_type Perform(const args_type& args) {\ 1374 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1375 Perform(this, args);\ 1376 }\ 1377 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1378 typename arg3_type, typename arg4_type, typename arg5_type, \ 1379 typename arg6_type, typename arg7_type, typename arg8_type, \ 1380 typename arg9_type>\ 1381 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1382 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1383 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1384 arg9_type arg9) const;\ 1385 GMOCK_INTERNAL_DEFN_##value_params\ 1386 private:\ 1387 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1388 };\ 1389 template <typename F> operator ::testing::Action<F>() const {\ 1390 return ::testing::Action<F>(\ 1391 new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\ 1392 }\ 1393 GMOCK_INTERNAL_DEFN_##value_params\ 1394 private:\ 1395 GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ 1396 };\ 1397 template <GMOCK_INTERNAL_DECL_##template_params\ 1398 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 1399 inline GMOCK_ACTION_CLASS_(name, value_params)<\ 1400 GMOCK_INTERNAL_LIST_##template_params\ 1401 GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ 1402 GMOCK_INTERNAL_DECL_##value_params) {\ 1403 return GMOCK_ACTION_CLASS_(name, value_params)<\ 1404 GMOCK_INTERNAL_LIST_##template_params\ 1405 GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ 1406 GMOCK_INTERNAL_LIST_##value_params);\ 1407 }\ 1408 template <GMOCK_INTERNAL_DECL_##template_params\ 1409 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 1410 template <typename F>\ 1411 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1412 typename arg3_type, typename arg4_type, typename arg5_type, \ 1413 typename arg6_type, typename arg7_type, typename arg8_type, \ 1414 typename arg9_type>\ 1415 typename ::testing::internal::Function<F>::Result\ 1416 GMOCK_ACTION_CLASS_(name, value_params)<\ 1417 GMOCK_INTERNAL_LIST_##template_params\ 1418 GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\ 1419 gmock_PerformImpl(\ 1420 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1421 1422#define ACTION(name)\ 1423 class name##Action {\ 1424 public:\ 1425 name##Action() {}\ 1426 template <typename F>\ 1427 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1428 public:\ 1429 typedef F function_type;\ 1430 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1431 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1432 args_type;\ 1433 gmock_Impl() {}\ 1434 virtual return_type Perform(const args_type& args) {\ 1435 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1436 Perform(this, args);\ 1437 }\ 1438 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1439 typename arg3_type, typename arg4_type, typename arg5_type, \ 1440 typename arg6_type, typename arg7_type, typename arg8_type, \ 1441 typename arg9_type>\ 1442 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1443 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1444 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1445 arg9_type arg9) const;\ 1446 private:\ 1447 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1448 };\ 1449 template <typename F> operator ::testing::Action<F>() const {\ 1450 return ::testing::Action<F>(new gmock_Impl<F>());\ 1451 }\ 1452 private:\ 1453 GTEST_DISALLOW_ASSIGN_(name##Action);\ 1454 };\ 1455 inline name##Action name() {\ 1456 return name##Action();\ 1457 }\ 1458 template <typename F>\ 1459 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1460 typename arg3_type, typename arg4_type, typename arg5_type, \ 1461 typename arg6_type, typename arg7_type, typename arg8_type, \ 1462 typename arg9_type>\ 1463 typename ::testing::internal::Function<F>::Result\ 1464 name##Action::gmock_Impl<F>::gmock_PerformImpl(\ 1465 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1466 1467#define ACTION_P(name, p0)\ 1468 template <typename p0##_type>\ 1469 class name##ActionP {\ 1470 public:\ 1471 explicit name##ActionP(p0##_type gmock_p0) : \ 1472 p0(::testing::internal::forward<p0##_type>(gmock_p0)) {}\ 1473 template <typename F>\ 1474 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1475 public:\ 1476 typedef F function_type;\ 1477 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1478 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1479 args_type;\ 1480 explicit gmock_Impl(p0##_type gmock_p0) : \ 1481 p0(::testing::internal::forward<p0##_type>(gmock_p0)) {}\ 1482 virtual return_type Perform(const args_type& args) {\ 1483 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1484 Perform(this, args);\ 1485 }\ 1486 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1487 typename arg3_type, typename arg4_type, typename arg5_type, \ 1488 typename arg6_type, typename arg7_type, typename arg8_type, \ 1489 typename arg9_type>\ 1490 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1491 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1492 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1493 arg9_type arg9) const;\ 1494 p0##_type p0;\ 1495 private:\ 1496 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1497 };\ 1498 template <typename F> operator ::testing::Action<F>() const {\ 1499 return ::testing::Action<F>(new gmock_Impl<F>(p0));\ 1500 }\ 1501 p0##_type p0;\ 1502 private:\ 1503 GTEST_DISALLOW_ASSIGN_(name##ActionP);\ 1504 };\ 1505 template <typename p0##_type>\ 1506 inline name##ActionP<p0##_type> name(p0##_type p0) {\ 1507 return name##ActionP<p0##_type>(p0);\ 1508 }\ 1509 template <typename p0##_type>\ 1510 template <typename F>\ 1511 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1512 typename arg3_type, typename arg4_type, typename arg5_type, \ 1513 typename arg6_type, typename arg7_type, typename arg8_type, \ 1514 typename arg9_type>\ 1515 typename ::testing::internal::Function<F>::Result\ 1516 name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1517 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1518 1519#define ACTION_P2(name, p0, p1)\ 1520 template <typename p0##_type, typename p1##_type>\ 1521 class name##ActionP2 {\ 1522 public:\ 1523 name##ActionP2(p0##_type gmock_p0, \ 1524 p1##_type gmock_p1) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1525 p1(::testing::internal::forward<p1##_type>(gmock_p1)) {}\ 1526 template <typename F>\ 1527 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1528 public:\ 1529 typedef F function_type;\ 1530 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1531 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1532 args_type;\ 1533 gmock_Impl(p0##_type gmock_p0, \ 1534 p1##_type gmock_p1) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1535 p1(::testing::internal::forward<p1##_type>(gmock_p1)) {}\ 1536 virtual return_type Perform(const args_type& args) {\ 1537 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1538 Perform(this, args);\ 1539 }\ 1540 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1541 typename arg3_type, typename arg4_type, typename arg5_type, \ 1542 typename arg6_type, typename arg7_type, typename arg8_type, \ 1543 typename arg9_type>\ 1544 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1545 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1546 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1547 arg9_type arg9) const;\ 1548 p0##_type p0;\ 1549 p1##_type p1;\ 1550 private:\ 1551 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1552 };\ 1553 template <typename F> operator ::testing::Action<F>() const {\ 1554 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\ 1555 }\ 1556 p0##_type p0;\ 1557 p1##_type p1;\ 1558 private:\ 1559 GTEST_DISALLOW_ASSIGN_(name##ActionP2);\ 1560 };\ 1561 template <typename p0##_type, typename p1##_type>\ 1562 inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \ 1563 p1##_type p1) {\ 1564 return name##ActionP2<p0##_type, p1##_type>(p0, p1);\ 1565 }\ 1566 template <typename p0##_type, typename p1##_type>\ 1567 template <typename F>\ 1568 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1569 typename arg3_type, typename arg4_type, typename arg5_type, \ 1570 typename arg6_type, typename arg7_type, typename arg8_type, \ 1571 typename arg9_type>\ 1572 typename ::testing::internal::Function<F>::Result\ 1573 name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1574 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1575 1576#define ACTION_P3(name, p0, p1, p2)\ 1577 template <typename p0##_type, typename p1##_type, typename p2##_type>\ 1578 class name##ActionP3 {\ 1579 public:\ 1580 name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \ 1581 p2##_type gmock_p2) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1582 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1583 p2(::testing::internal::forward<p2##_type>(gmock_p2)) {}\ 1584 template <typename F>\ 1585 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1586 public:\ 1587 typedef F function_type;\ 1588 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1589 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1590 args_type;\ 1591 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \ 1592 p2##_type gmock_p2) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1593 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1594 p2(::testing::internal::forward<p2##_type>(gmock_p2)) {}\ 1595 virtual return_type Perform(const args_type& args) {\ 1596 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1597 Perform(this, args);\ 1598 }\ 1599 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1600 typename arg3_type, typename arg4_type, typename arg5_type, \ 1601 typename arg6_type, typename arg7_type, typename arg8_type, \ 1602 typename arg9_type>\ 1603 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1604 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1605 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1606 arg9_type arg9) const;\ 1607 p0##_type p0;\ 1608 p1##_type p1;\ 1609 p2##_type p2;\ 1610 private:\ 1611 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1612 };\ 1613 template <typename F> operator ::testing::Action<F>() const {\ 1614 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\ 1615 }\ 1616 p0##_type p0;\ 1617 p1##_type p1;\ 1618 p2##_type p2;\ 1619 private:\ 1620 GTEST_DISALLOW_ASSIGN_(name##ActionP3);\ 1621 };\ 1622 template <typename p0##_type, typename p1##_type, typename p2##_type>\ 1623 inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \ 1624 p1##_type p1, p2##_type p2) {\ 1625 return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\ 1626 }\ 1627 template <typename p0##_type, typename p1##_type, typename p2##_type>\ 1628 template <typename F>\ 1629 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1630 typename arg3_type, typename arg4_type, typename arg5_type, \ 1631 typename arg6_type, typename arg7_type, typename arg8_type, \ 1632 typename arg9_type>\ 1633 typename ::testing::internal::Function<F>::Result\ 1634 name##ActionP3<p0##_type, p1##_type, \ 1635 p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1636 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1637 1638#define ACTION_P4(name, p0, p1, p2, p3)\ 1639 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1640 typename p3##_type>\ 1641 class name##ActionP4 {\ 1642 public:\ 1643 name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \ 1644 p2##_type gmock_p2, \ 1645 p3##_type gmock_p3) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1646 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1647 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1648 p3(::testing::internal::forward<p3##_type>(gmock_p3)) {}\ 1649 template <typename F>\ 1650 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1651 public:\ 1652 typedef F function_type;\ 1653 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1654 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1655 args_type;\ 1656 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1657 p3##_type gmock_p3) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1658 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1659 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1660 p3(::testing::internal::forward<p3##_type>(gmock_p3)) {}\ 1661 virtual return_type Perform(const args_type& args) {\ 1662 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1663 Perform(this, args);\ 1664 }\ 1665 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1666 typename arg3_type, typename arg4_type, typename arg5_type, \ 1667 typename arg6_type, typename arg7_type, typename arg8_type, \ 1668 typename arg9_type>\ 1669 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1670 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1671 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1672 arg9_type arg9) const;\ 1673 p0##_type p0;\ 1674 p1##_type p1;\ 1675 p2##_type p2;\ 1676 p3##_type p3;\ 1677 private:\ 1678 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1679 };\ 1680 template <typename F> operator ::testing::Action<F>() const {\ 1681 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\ 1682 }\ 1683 p0##_type p0;\ 1684 p1##_type p1;\ 1685 p2##_type p2;\ 1686 p3##_type p3;\ 1687 private:\ 1688 GTEST_DISALLOW_ASSIGN_(name##ActionP4);\ 1689 };\ 1690 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1691 typename p3##_type>\ 1692 inline name##ActionP4<p0##_type, p1##_type, p2##_type, \ 1693 p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ 1694 p3##_type p3) {\ 1695 return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \ 1696 p2, p3);\ 1697 }\ 1698 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1699 typename p3##_type>\ 1700 template <typename F>\ 1701 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1702 typename arg3_type, typename arg4_type, typename arg5_type, \ 1703 typename arg6_type, typename arg7_type, typename arg8_type, \ 1704 typename arg9_type>\ 1705 typename ::testing::internal::Function<F>::Result\ 1706 name##ActionP4<p0##_type, p1##_type, p2##_type, \ 1707 p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1708 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1709 1710#define ACTION_P5(name, p0, p1, p2, p3, p4)\ 1711 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1712 typename p3##_type, typename p4##_type>\ 1713 class name##ActionP5 {\ 1714 public:\ 1715 name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \ 1716 p2##_type gmock_p2, p3##_type gmock_p3, \ 1717 p4##_type gmock_p4) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1718 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1719 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1720 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1721 p4(::testing::internal::forward<p4##_type>(gmock_p4)) {}\ 1722 template <typename F>\ 1723 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1724 public:\ 1725 typedef F function_type;\ 1726 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1727 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1728 args_type;\ 1729 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1730 p3##_type gmock_p3, \ 1731 p4##_type gmock_p4) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1732 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1733 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1734 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1735 p4(::testing::internal::forward<p4##_type>(gmock_p4)) {}\ 1736 virtual return_type Perform(const args_type& args) {\ 1737 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1738 Perform(this, args);\ 1739 }\ 1740 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1741 typename arg3_type, typename arg4_type, typename arg5_type, \ 1742 typename arg6_type, typename arg7_type, typename arg8_type, \ 1743 typename arg9_type>\ 1744 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1745 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1746 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1747 arg9_type arg9) const;\ 1748 p0##_type p0;\ 1749 p1##_type p1;\ 1750 p2##_type p2;\ 1751 p3##_type p3;\ 1752 p4##_type p4;\ 1753 private:\ 1754 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1755 };\ 1756 template <typename F> operator ::testing::Action<F>() const {\ 1757 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\ 1758 }\ 1759 p0##_type p0;\ 1760 p1##_type p1;\ 1761 p2##_type p2;\ 1762 p3##_type p3;\ 1763 p4##_type p4;\ 1764 private:\ 1765 GTEST_DISALLOW_ASSIGN_(name##ActionP5);\ 1766 };\ 1767 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1768 typename p3##_type, typename p4##_type>\ 1769 inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \ 1770 p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 1771 p4##_type p4) {\ 1772 return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \ 1773 p4##_type>(p0, p1, p2, p3, p4);\ 1774 }\ 1775 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1776 typename p3##_type, typename p4##_type>\ 1777 template <typename F>\ 1778 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1779 typename arg3_type, typename arg4_type, typename arg5_type, \ 1780 typename arg6_type, typename arg7_type, typename arg8_type, \ 1781 typename arg9_type>\ 1782 typename ::testing::internal::Function<F>::Result\ 1783 name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \ 1784 p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1785 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1786 1787#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\ 1788 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1789 typename p3##_type, typename p4##_type, typename p5##_type>\ 1790 class name##ActionP6 {\ 1791 public:\ 1792 name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \ 1793 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 1794 p5##_type gmock_p5) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1795 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1796 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1797 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1798 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 1799 p5(::testing::internal::forward<p5##_type>(gmock_p5)) {}\ 1800 template <typename F>\ 1801 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1802 public:\ 1803 typedef F function_type;\ 1804 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1805 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1806 args_type;\ 1807 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1808 p3##_type gmock_p3, p4##_type gmock_p4, \ 1809 p5##_type gmock_p5) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1810 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1811 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1812 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1813 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 1814 p5(::testing::internal::forward<p5##_type>(gmock_p5)) {}\ 1815 virtual return_type Perform(const args_type& args) {\ 1816 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1817 Perform(this, args);\ 1818 }\ 1819 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1820 typename arg3_type, typename arg4_type, typename arg5_type, \ 1821 typename arg6_type, typename arg7_type, typename arg8_type, \ 1822 typename arg9_type>\ 1823 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1824 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1825 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1826 arg9_type arg9) const;\ 1827 p0##_type p0;\ 1828 p1##_type p1;\ 1829 p2##_type p2;\ 1830 p3##_type p3;\ 1831 p4##_type p4;\ 1832 p5##_type p5;\ 1833 private:\ 1834 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1835 };\ 1836 template <typename F> operator ::testing::Action<F>() const {\ 1837 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\ 1838 }\ 1839 p0##_type p0;\ 1840 p1##_type p1;\ 1841 p2##_type p2;\ 1842 p3##_type p3;\ 1843 p4##_type p4;\ 1844 p5##_type p5;\ 1845 private:\ 1846 GTEST_DISALLOW_ASSIGN_(name##ActionP6);\ 1847 };\ 1848 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1849 typename p3##_type, typename p4##_type, typename p5##_type>\ 1850 inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \ 1851 p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ 1852 p3##_type p3, p4##_type p4, p5##_type p5) {\ 1853 return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \ 1854 p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\ 1855 }\ 1856 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1857 typename p3##_type, typename p4##_type, typename p5##_type>\ 1858 template <typename F>\ 1859 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1860 typename arg3_type, typename arg4_type, typename arg5_type, \ 1861 typename arg6_type, typename arg7_type, typename arg8_type, \ 1862 typename arg9_type>\ 1863 typename ::testing::internal::Function<F>::Result\ 1864 name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1865 p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1866 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1867 1868#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\ 1869 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1870 typename p3##_type, typename p4##_type, typename p5##_type, \ 1871 typename p6##_type>\ 1872 class name##ActionP7 {\ 1873 public:\ 1874 name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \ 1875 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 1876 p5##_type gmock_p5, \ 1877 p6##_type gmock_p6) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1878 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1879 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1880 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1881 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 1882 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 1883 p6(::testing::internal::forward<p6##_type>(gmock_p6)) {}\ 1884 template <typename F>\ 1885 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1886 public:\ 1887 typedef F function_type;\ 1888 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1889 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1890 args_type;\ 1891 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1892 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1893 p6##_type gmock_p6) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1894 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1895 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1896 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1897 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 1898 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 1899 p6(::testing::internal::forward<p6##_type>(gmock_p6)) {}\ 1900 virtual return_type Perform(const args_type& args) {\ 1901 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1902 Perform(this, args);\ 1903 }\ 1904 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1905 typename arg3_type, typename arg4_type, typename arg5_type, \ 1906 typename arg6_type, typename arg7_type, typename arg8_type, \ 1907 typename arg9_type>\ 1908 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 1909 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 1910 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 1911 arg9_type arg9) const;\ 1912 p0##_type p0;\ 1913 p1##_type p1;\ 1914 p2##_type p2;\ 1915 p3##_type p3;\ 1916 p4##_type p4;\ 1917 p5##_type p5;\ 1918 p6##_type p6;\ 1919 private:\ 1920 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 1921 };\ 1922 template <typename F> operator ::testing::Action<F>() const {\ 1923 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ 1924 p6));\ 1925 }\ 1926 p0##_type p0;\ 1927 p1##_type p1;\ 1928 p2##_type p2;\ 1929 p3##_type p3;\ 1930 p4##_type p4;\ 1931 p5##_type p5;\ 1932 p6##_type p6;\ 1933 private:\ 1934 GTEST_DISALLOW_ASSIGN_(name##ActionP7);\ 1935 };\ 1936 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1937 typename p3##_type, typename p4##_type, typename p5##_type, \ 1938 typename p6##_type>\ 1939 inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \ 1940 p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \ 1941 p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ 1942 p6##_type p6) {\ 1943 return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \ 1944 p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\ 1945 }\ 1946 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1947 typename p3##_type, typename p4##_type, typename p5##_type, \ 1948 typename p6##_type>\ 1949 template <typename F>\ 1950 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1951 typename arg3_type, typename arg4_type, typename arg5_type, \ 1952 typename arg6_type, typename arg7_type, typename arg8_type, \ 1953 typename arg9_type>\ 1954 typename ::testing::internal::Function<F>::Result\ 1955 name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 1956 p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 1957 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 1958 1959#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\ 1960 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 1961 typename p3##_type, typename p4##_type, typename p5##_type, \ 1962 typename p6##_type, typename p7##_type>\ 1963 class name##ActionP8 {\ 1964 public:\ 1965 name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \ 1966 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 1967 p5##_type gmock_p5, p6##_type gmock_p6, \ 1968 p7##_type gmock_p7) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1969 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1970 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1971 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1972 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 1973 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 1974 p6(::testing::internal::forward<p6##_type>(gmock_p6)), \ 1975 p7(::testing::internal::forward<p7##_type>(gmock_p7)) {}\ 1976 template <typename F>\ 1977 class gmock_Impl : public ::testing::ActionInterface<F> {\ 1978 public:\ 1979 typedef F function_type;\ 1980 typedef typename ::testing::internal::Function<F>::Result return_type;\ 1981 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 1982 args_type;\ 1983 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 1984 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 1985 p6##_type gmock_p6, \ 1986 p7##_type gmock_p7) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 1987 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 1988 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 1989 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 1990 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 1991 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 1992 p6(::testing::internal::forward<p6##_type>(gmock_p6)), \ 1993 p7(::testing::internal::forward<p7##_type>(gmock_p7)) {}\ 1994 virtual return_type Perform(const args_type& args) {\ 1995 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 1996 Perform(this, args);\ 1997 }\ 1998 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 1999 typename arg3_type, typename arg4_type, typename arg5_type, \ 2000 typename arg6_type, typename arg7_type, typename arg8_type, \ 2001 typename arg9_type>\ 2002 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 2003 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 2004 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 2005 arg9_type arg9) const;\ 2006 p0##_type p0;\ 2007 p1##_type p1;\ 2008 p2##_type p2;\ 2009 p3##_type p3;\ 2010 p4##_type p4;\ 2011 p5##_type p5;\ 2012 p6##_type p6;\ 2013 p7##_type p7;\ 2014 private:\ 2015 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 2016 };\ 2017 template <typename F> operator ::testing::Action<F>() const {\ 2018 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ 2019 p6, p7));\ 2020 }\ 2021 p0##_type p0;\ 2022 p1##_type p1;\ 2023 p2##_type p2;\ 2024 p3##_type p3;\ 2025 p4##_type p4;\ 2026 p5##_type p5;\ 2027 p6##_type p6;\ 2028 p7##_type p7;\ 2029 private:\ 2030 GTEST_DISALLOW_ASSIGN_(name##ActionP8);\ 2031 };\ 2032 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2033 typename p3##_type, typename p4##_type, typename p5##_type, \ 2034 typename p6##_type, typename p7##_type>\ 2035 inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \ 2036 p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \ 2037 p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ 2038 p6##_type p6, p7##_type p7) {\ 2039 return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \ 2040 p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \ 2041 p6, p7);\ 2042 }\ 2043 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2044 typename p3##_type, typename p4##_type, typename p5##_type, \ 2045 typename p6##_type, typename p7##_type>\ 2046 template <typename F>\ 2047 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 2048 typename arg3_type, typename arg4_type, typename arg5_type, \ 2049 typename arg6_type, typename arg7_type, typename arg8_type, \ 2050 typename arg9_type>\ 2051 typename ::testing::internal::Function<F>::Result\ 2052 name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 2053 p5##_type, p6##_type, \ 2054 p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 2055 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 2056 2057#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\ 2058 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2059 typename p3##_type, typename p4##_type, typename p5##_type, \ 2060 typename p6##_type, typename p7##_type, typename p8##_type>\ 2061 class name##ActionP9 {\ 2062 public:\ 2063 name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \ 2064 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 2065 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ 2066 p8##_type gmock_p8) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 2067 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 2068 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 2069 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 2070 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 2071 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 2072 p6(::testing::internal::forward<p6##_type>(gmock_p6)), \ 2073 p7(::testing::internal::forward<p7##_type>(gmock_p7)), \ 2074 p8(::testing::internal::forward<p8##_type>(gmock_p8)) {}\ 2075 template <typename F>\ 2076 class gmock_Impl : public ::testing::ActionInterface<F> {\ 2077 public:\ 2078 typedef F function_type;\ 2079 typedef typename ::testing::internal::Function<F>::Result return_type;\ 2080 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 2081 args_type;\ 2082 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 2083 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 2084 p6##_type gmock_p6, p7##_type gmock_p7, \ 2085 p8##_type gmock_p8) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 2086 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 2087 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 2088 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 2089 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 2090 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 2091 p6(::testing::internal::forward<p6##_type>(gmock_p6)), \ 2092 p7(::testing::internal::forward<p7##_type>(gmock_p7)), \ 2093 p8(::testing::internal::forward<p8##_type>(gmock_p8)) {}\ 2094 virtual return_type Perform(const args_type& args) {\ 2095 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 2096 Perform(this, args);\ 2097 }\ 2098 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 2099 typename arg3_type, typename arg4_type, typename arg5_type, \ 2100 typename arg6_type, typename arg7_type, typename arg8_type, \ 2101 typename arg9_type>\ 2102 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 2103 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 2104 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 2105 arg9_type arg9) const;\ 2106 p0##_type p0;\ 2107 p1##_type p1;\ 2108 p2##_type p2;\ 2109 p3##_type p3;\ 2110 p4##_type p4;\ 2111 p5##_type p5;\ 2112 p6##_type p6;\ 2113 p7##_type p7;\ 2114 p8##_type p8;\ 2115 private:\ 2116 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 2117 };\ 2118 template <typename F> operator ::testing::Action<F>() const {\ 2119 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ 2120 p6, p7, p8));\ 2121 }\ 2122 p0##_type p0;\ 2123 p1##_type p1;\ 2124 p2##_type p2;\ 2125 p3##_type p3;\ 2126 p4##_type p4;\ 2127 p5##_type p5;\ 2128 p6##_type p6;\ 2129 p7##_type p7;\ 2130 p8##_type p8;\ 2131 private:\ 2132 GTEST_DISALLOW_ASSIGN_(name##ActionP9);\ 2133 };\ 2134 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2135 typename p3##_type, typename p4##_type, typename p5##_type, \ 2136 typename p6##_type, typename p7##_type, typename p8##_type>\ 2137 inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \ 2138 p4##_type, p5##_type, p6##_type, p7##_type, \ 2139 p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 2140 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ 2141 p8##_type p8) {\ 2142 return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \ 2143 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \ 2144 p3, p4, p5, p6, p7, p8);\ 2145 }\ 2146 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2147 typename p3##_type, typename p4##_type, typename p5##_type, \ 2148 typename p6##_type, typename p7##_type, typename p8##_type>\ 2149 template <typename F>\ 2150 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 2151 typename arg3_type, typename arg4_type, typename arg5_type, \ 2152 typename arg6_type, typename arg7_type, typename arg8_type, \ 2153 typename arg9_type>\ 2154 typename ::testing::internal::Function<F>::Result\ 2155 name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 2156 p5##_type, p6##_type, p7##_type, \ 2157 p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 2158 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 2159 2160#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\ 2161 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2162 typename p3##_type, typename p4##_type, typename p5##_type, \ 2163 typename p6##_type, typename p7##_type, typename p8##_type, \ 2164 typename p9##_type>\ 2165 class name##ActionP10 {\ 2166 public:\ 2167 name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \ 2168 p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ 2169 p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ 2170 p8##_type gmock_p8, \ 2171 p9##_type gmock_p9) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 2172 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 2173 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 2174 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 2175 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 2176 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 2177 p6(::testing::internal::forward<p6##_type>(gmock_p6)), \ 2178 p7(::testing::internal::forward<p7##_type>(gmock_p7)), \ 2179 p8(::testing::internal::forward<p8##_type>(gmock_p8)), \ 2180 p9(::testing::internal::forward<p9##_type>(gmock_p9)) {}\ 2181 template <typename F>\ 2182 class gmock_Impl : public ::testing::ActionInterface<F> {\ 2183 public:\ 2184 typedef F function_type;\ 2185 typedef typename ::testing::internal::Function<F>::Result return_type;\ 2186 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 2187 args_type;\ 2188 gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 2189 p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 2190 p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ 2191 p9##_type gmock_p9) : p0(::testing::internal::forward<p0##_type>(gmock_p0)), \ 2192 p1(::testing::internal::forward<p1##_type>(gmock_p1)), \ 2193 p2(::testing::internal::forward<p2##_type>(gmock_p2)), \ 2194 p3(::testing::internal::forward<p3##_type>(gmock_p3)), \ 2195 p4(::testing::internal::forward<p4##_type>(gmock_p4)), \ 2196 p5(::testing::internal::forward<p5##_type>(gmock_p5)), \ 2197 p6(::testing::internal::forward<p6##_type>(gmock_p6)), \ 2198 p7(::testing::internal::forward<p7##_type>(gmock_p7)), \ 2199 p8(::testing::internal::forward<p8##_type>(gmock_p8)), \ 2200 p9(::testing::internal::forward<p9##_type>(gmock_p9)) {}\ 2201 virtual return_type Perform(const args_type& args) {\ 2202 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 2203 Perform(this, args);\ 2204 }\ 2205 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 2206 typename arg3_type, typename arg4_type, typename arg5_type, \ 2207 typename arg6_type, typename arg7_type, typename arg8_type, \ 2208 typename arg9_type>\ 2209 return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ 2210 arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ 2211 arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ 2212 arg9_type arg9) const;\ 2213 p0##_type p0;\ 2214 p1##_type p1;\ 2215 p2##_type p2;\ 2216 p3##_type p3;\ 2217 p4##_type p4;\ 2218 p5##_type p5;\ 2219 p6##_type p6;\ 2220 p7##_type p7;\ 2221 p8##_type p8;\ 2222 p9##_type p9;\ 2223 private:\ 2224 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 2225 };\ 2226 template <typename F> operator ::testing::Action<F>() const {\ 2227 return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ 2228 p6, p7, p8, p9));\ 2229 }\ 2230 p0##_type p0;\ 2231 p1##_type p1;\ 2232 p2##_type p2;\ 2233 p3##_type p3;\ 2234 p4##_type p4;\ 2235 p5##_type p5;\ 2236 p6##_type p6;\ 2237 p7##_type p7;\ 2238 p8##_type p8;\ 2239 p9##_type p9;\ 2240 private:\ 2241 GTEST_DISALLOW_ASSIGN_(name##ActionP10);\ 2242 };\ 2243 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2244 typename p3##_type, typename p4##_type, typename p5##_type, \ 2245 typename p6##_type, typename p7##_type, typename p8##_type, \ 2246 typename p9##_type>\ 2247 inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \ 2248 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ 2249 p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 2250 p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ 2251 p9##_type p9) {\ 2252 return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \ 2253 p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \ 2254 p1, p2, p3, p4, p5, p6, p7, p8, p9);\ 2255 }\ 2256 template <typename p0##_type, typename p1##_type, typename p2##_type, \ 2257 typename p3##_type, typename p4##_type, typename p5##_type, \ 2258 typename p6##_type, typename p7##_type, typename p8##_type, \ 2259 typename p9##_type>\ 2260 template <typename F>\ 2261 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 2262 typename arg3_type, typename arg4_type, typename arg5_type, \ 2263 typename arg6_type, typename arg7_type, typename arg8_type, \ 2264 typename arg9_type>\ 2265 typename ::testing::internal::Function<F>::Result\ 2266 name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 2267 p5##_type, p6##_type, p7##_type, p8##_type, \ 2268 p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\ 2269 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 2270 2271namespace testing { 2272 2273 2274// The ACTION*() macros trigger warning C4100 (unreferenced formal 2275// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in 2276// the macro definition, as the warnings are generated when the macro 2277// is expanded and macro expansion cannot contain #pragma. Therefore 2278// we suppress them here. 2279#ifdef _MSC_VER 2280# pragma warning(push) 2281# pragma warning(disable:4100) 2282#endif 2283 2284// Various overloads for InvokeArgument<N>(). 2285// 2286// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th 2287// (0-based) argument, which must be a k-ary callable, of the mock 2288// function, with arguments a1, a2, ..., a_k. 2289// 2290// Notes: 2291// 2292// 1. The arguments are passed by value by default. If you need to 2293// pass an argument by reference, wrap it inside ByRef(). For 2294// example, 2295// 2296// InvokeArgument<1>(5, string("Hello"), ByRef(foo)) 2297// 2298// passes 5 and string("Hello") by value, and passes foo by 2299// reference. 2300// 2301// 2. If the callable takes an argument by reference but ByRef() is 2302// not used, it will receive the reference to a copy of the value, 2303// instead of the original value. For example, when the 0-th 2304// argument of the mock function takes a const string&, the action 2305// 2306// InvokeArgument<0>(string("Hello")) 2307// 2308// makes a copy of the temporary string("Hello") object and passes a 2309// reference of the copy, instead of the original temporary object, 2310// to the callable. This makes it easy for a user to define an 2311// InvokeArgument action from temporary values and have it performed 2312// later. 2313 2314namespace internal { 2315namespace invoke_argument { 2316 2317// Appears in InvokeArgumentAdl's argument list to help avoid 2318// accidental calls to user functions of the same name. 2319struct AdlTag {}; 2320 2321// InvokeArgumentAdl - a helper for InvokeArgument. 2322// The basic overloads are provided here for generic functors. 2323// Overloads for other custom-callables are provided in the 2324// internal/custom/callback-actions.h header. 2325 2326template <typename R, typename F> 2327R InvokeArgumentAdl(AdlTag, F f) { 2328 return f(); 2329} 2330template <typename R, typename F, typename A1> 2331R InvokeArgumentAdl(AdlTag, F f, A1 a1) { 2332 return f(a1); 2333} 2334template <typename R, typename F, typename A1, typename A2> 2335R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) { 2336 return f(a1, a2); 2337} 2338template <typename R, typename F, typename A1, typename A2, typename A3> 2339R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) { 2340 return f(a1, a2, a3); 2341} 2342template <typename R, typename F, typename A1, typename A2, typename A3, 2343 typename A4> 2344R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) { 2345 return f(a1, a2, a3, a4); 2346} 2347template <typename R, typename F, typename A1, typename A2, typename A3, 2348 typename A4, typename A5> 2349R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { 2350 return f(a1, a2, a3, a4, a5); 2351} 2352template <typename R, typename F, typename A1, typename A2, typename A3, 2353 typename A4, typename A5, typename A6> 2354R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { 2355 return f(a1, a2, a3, a4, a5, a6); 2356} 2357template <typename R, typename F, typename A1, typename A2, typename A3, 2358 typename A4, typename A5, typename A6, typename A7> 2359R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, 2360 A7 a7) { 2361 return f(a1, a2, a3, a4, a5, a6, a7); 2362} 2363template <typename R, typename F, typename A1, typename A2, typename A3, 2364 typename A4, typename A5, typename A6, typename A7, typename A8> 2365R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, 2366 A7 a7, A8 a8) { 2367 return f(a1, a2, a3, a4, a5, a6, a7, a8); 2368} 2369template <typename R, typename F, typename A1, typename A2, typename A3, 2370 typename A4, typename A5, typename A6, typename A7, typename A8, 2371 typename A9> 2372R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, 2373 A7 a7, A8 a8, A9 a9) { 2374 return f(a1, a2, a3, a4, a5, a6, a7, a8, a9); 2375} 2376template <typename R, typename F, typename A1, typename A2, typename A3, 2377 typename A4, typename A5, typename A6, typename A7, typename A8, 2378 typename A9, typename A10> 2379R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, 2380 A7 a7, A8 a8, A9 a9, A10 a10) { 2381 return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 2382} 2383} // namespace invoke_argument 2384} // namespace internal 2385 2386ACTION_TEMPLATE(InvokeArgument, 2387 HAS_1_TEMPLATE_PARAMS(int, k), 2388 AND_0_VALUE_PARAMS()) { 2389 using internal::invoke_argument::InvokeArgumentAdl; 2390 return InvokeArgumentAdl<return_type>( 2391 internal::invoke_argument::AdlTag(), 2392 ::testing::get<k>(args)); 2393} 2394 2395ACTION_TEMPLATE(InvokeArgument, 2396 HAS_1_TEMPLATE_PARAMS(int, k), 2397 AND_1_VALUE_PARAMS(p0)) { 2398 using internal::invoke_argument::InvokeArgumentAdl; 2399 return InvokeArgumentAdl<return_type>( 2400 internal::invoke_argument::AdlTag(), 2401 ::testing::get<k>(args), p0); 2402} 2403 2404ACTION_TEMPLATE(InvokeArgument, 2405 HAS_1_TEMPLATE_PARAMS(int, k), 2406 AND_2_VALUE_PARAMS(p0, p1)) { 2407 using internal::invoke_argument::InvokeArgumentAdl; 2408 return InvokeArgumentAdl<return_type>( 2409 internal::invoke_argument::AdlTag(), 2410 ::testing::get<k>(args), p0, p1); 2411} 2412 2413ACTION_TEMPLATE(InvokeArgument, 2414 HAS_1_TEMPLATE_PARAMS(int, k), 2415 AND_3_VALUE_PARAMS(p0, p1, p2)) { 2416 using internal::invoke_argument::InvokeArgumentAdl; 2417 return InvokeArgumentAdl<return_type>( 2418 internal::invoke_argument::AdlTag(), 2419 ::testing::get<k>(args), p0, p1, p2); 2420} 2421 2422ACTION_TEMPLATE(InvokeArgument, 2423 HAS_1_TEMPLATE_PARAMS(int, k), 2424 AND_4_VALUE_PARAMS(p0, p1, p2, p3)) { 2425 using internal::invoke_argument::InvokeArgumentAdl; 2426 return InvokeArgumentAdl<return_type>( 2427 internal::invoke_argument::AdlTag(), 2428 ::testing::get<k>(args), p0, p1, p2, p3); 2429} 2430 2431ACTION_TEMPLATE(InvokeArgument, 2432 HAS_1_TEMPLATE_PARAMS(int, k), 2433 AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) { 2434 using internal::invoke_argument::InvokeArgumentAdl; 2435 return InvokeArgumentAdl<return_type>( 2436 internal::invoke_argument::AdlTag(), 2437 ::testing::get<k>(args), p0, p1, p2, p3, p4); 2438} 2439 2440ACTION_TEMPLATE(InvokeArgument, 2441 HAS_1_TEMPLATE_PARAMS(int, k), 2442 AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) { 2443 using internal::invoke_argument::InvokeArgumentAdl; 2444 return InvokeArgumentAdl<return_type>( 2445 internal::invoke_argument::AdlTag(), 2446 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5); 2447} 2448 2449ACTION_TEMPLATE(InvokeArgument, 2450 HAS_1_TEMPLATE_PARAMS(int, k), 2451 AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) { 2452 using internal::invoke_argument::InvokeArgumentAdl; 2453 return InvokeArgumentAdl<return_type>( 2454 internal::invoke_argument::AdlTag(), 2455 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6); 2456} 2457 2458ACTION_TEMPLATE(InvokeArgument, 2459 HAS_1_TEMPLATE_PARAMS(int, k), 2460 AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) { 2461 using internal::invoke_argument::InvokeArgumentAdl; 2462 return InvokeArgumentAdl<return_type>( 2463 internal::invoke_argument::AdlTag(), 2464 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7); 2465} 2466 2467ACTION_TEMPLATE(InvokeArgument, 2468 HAS_1_TEMPLATE_PARAMS(int, k), 2469 AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) { 2470 using internal::invoke_argument::InvokeArgumentAdl; 2471 return InvokeArgumentAdl<return_type>( 2472 internal::invoke_argument::AdlTag(), 2473 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8); 2474} 2475 2476ACTION_TEMPLATE(InvokeArgument, 2477 HAS_1_TEMPLATE_PARAMS(int, k), 2478 AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) { 2479 using internal::invoke_argument::InvokeArgumentAdl; 2480 return InvokeArgumentAdl<return_type>( 2481 internal::invoke_argument::AdlTag(), 2482 ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); 2483} 2484 2485// Various overloads for ReturnNew<T>(). 2486// 2487// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new 2488// instance of type T, constructed on the heap with constructor arguments 2489// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. 2490ACTION_TEMPLATE(ReturnNew, 2491 HAS_1_TEMPLATE_PARAMS(typename, T), 2492 AND_0_VALUE_PARAMS()) { 2493 return new T(); 2494} 2495 2496ACTION_TEMPLATE(ReturnNew, 2497 HAS_1_TEMPLATE_PARAMS(typename, T), 2498 AND_1_VALUE_PARAMS(p0)) { 2499 return new T(p0); 2500} 2501 2502ACTION_TEMPLATE(ReturnNew, 2503 HAS_1_TEMPLATE_PARAMS(typename, T), 2504 AND_2_VALUE_PARAMS(p0, p1)) { 2505 return new T(p0, p1); 2506} 2507 2508ACTION_TEMPLATE(ReturnNew, 2509 HAS_1_TEMPLATE_PARAMS(typename, T), 2510 AND_3_VALUE_PARAMS(p0, p1, p2)) { 2511 return new T(p0, p1, p2); 2512} 2513 2514ACTION_TEMPLATE(ReturnNew, 2515 HAS_1_TEMPLATE_PARAMS(typename, T), 2516 AND_4_VALUE_PARAMS(p0, p1, p2, p3)) { 2517 return new T(p0, p1, p2, p3); 2518} 2519 2520ACTION_TEMPLATE(ReturnNew, 2521 HAS_1_TEMPLATE_PARAMS(typename, T), 2522 AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) { 2523 return new T(p0, p1, p2, p3, p4); 2524} 2525 2526ACTION_TEMPLATE(ReturnNew, 2527 HAS_1_TEMPLATE_PARAMS(typename, T), 2528 AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) { 2529 return new T(p0, p1, p2, p3, p4, p5); 2530} 2531 2532ACTION_TEMPLATE(ReturnNew, 2533 HAS_1_TEMPLATE_PARAMS(typename, T), 2534 AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) { 2535 return new T(p0, p1, p2, p3, p4, p5, p6); 2536} 2537 2538ACTION_TEMPLATE(ReturnNew, 2539 HAS_1_TEMPLATE_PARAMS(typename, T), 2540 AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) { 2541 return new T(p0, p1, p2, p3, p4, p5, p6, p7); 2542} 2543 2544ACTION_TEMPLATE(ReturnNew, 2545 HAS_1_TEMPLATE_PARAMS(typename, T), 2546 AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) { 2547 return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8); 2548} 2549 2550ACTION_TEMPLATE(ReturnNew, 2551 HAS_1_TEMPLATE_PARAMS(typename, T), 2552 AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) { 2553 return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); 2554} 2555 2556#ifdef _MSC_VER 2557# pragma warning(pop) 2558#endif 2559 2560} // namespace testing 2561 2562// Include any custom callback actions added by the local installation. 2563// We must include this header at the end to make sure it can use the 2564// declarations from this file. 2565#include "gmock/internal/custom/gmock-generated-actions.h" 2566 2567#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 2568