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