1 $$ -*- mode: c++; -*- 2 $$ This is a Pump source file. Please use Pump to convert it to 3 $$ gmock-generated-actions.h. 4 $$ 5 $var n = 10 $$ The maximum arity we support. 6 $$}} This meta comment fixes auto-indentation in editors. 7 // Copyright 2007, Google Inc. 8 // All rights reserved. 9 // 10 // Redistribution and use in source and binary forms, with or without 11 // modification, are permitted provided that the following conditions are 12 // met: 13 // 14 // * Redistributions of source code must retain the above copyright 15 // notice, this list of conditions and the following disclaimer. 16 // * Redistributions in binary form must reproduce the above 17 // copyright notice, this list of conditions and the following disclaimer 18 // in the documentation and/or other materials provided with the 19 // distribution. 20 // * Neither the name of Google Inc. nor the names of its 21 // contributors may be used to endorse or promote products derived from 22 // this software without specific prior written permission. 23 // 24 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 25 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 26 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 27 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 28 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 29 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 30 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 31 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 32 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 33 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 34 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 35 36 37 // Google Mock - a framework for writing C++ mock classes. 38 // 39 // This file implements some commonly used variadic actions. 40 41 // GOOGLETEST_CM0002 DO NOT DELETE 42 43 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 44 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 45 46 #include <memory> 47 #include <utility> 48 49 #include "gmock/gmock-actions.h" 50 #include "gmock/internal/gmock-port.h" 51 52 namespace testing { 53 namespace internal { 54 55 // A macro from the ACTION* family (defined later in this file) 56 // defines an action that can be used in a mock function. Typically, 57 // these actions only care about a subset of the arguments of the mock 58 // function. For example, if such an action only uses the second 59 // argument, it can be used in any mock function that takes >= 2 60 // arguments where the type of the second argument is compatible. 61 // 62 // Therefore, the action implementation must be prepared to take more 63 // arguments than it needs. The ExcessiveArg type is used to 64 // represent those excessive arguments. In order to keep the compiler 65 // error messages tractable, we define it in the testing namespace 66 // instead of testing::internal. However, this is an INTERNAL TYPE 67 // and subject to change without notice, so a user MUST NOT USE THIS 68 // TYPE DIRECTLY. 69 struct ExcessiveArg {}; 70 71 // A helper class needed for implementing the ACTION* macros. 72 template <typename Result, class Impl> 73 class ActionHelper { 74 public: 75 $range i 0..n 76 $for i 77 78 [[ 79 $var template = [[$if i==0 [[]] $else [[ 80 $range j 0..i-1 81 template <$for j, [[typename A$j]]> 82 ]]]] 83 $range j 0..i-1 84 $var As = [[$for j, [[A$j]]]] 85 $var as = [[$for j, [[std::get<$j>(args)]]]] 86 $range k 1..n-i 87 $var eas = [[$for k, [[ExcessiveArg()]]]] 88 $var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]] 89 $template 90 static Result Perform(Impl* impl, const ::std::tuple<$As>& args) { 91 return impl->template gmock_PerformImpl<$As>(args, $arg_list); 92 } 93 94 ]] 95 }; 96 97 } // namespace internal 98 } // namespace testing 99 100 // The ACTION* family of macros can be used in a namespace scope to 101 // define custom actions easily. The syntax: 102 // 103 // ACTION(name) { statements; } 104 // 105 // will define an action with the given name that executes the 106 // statements. The value returned by the statements will be used as 107 // the return value of the action. Inside the statements, you can 108 // refer to the K-th (0-based) argument of the mock function by 109 // 'argK', and refer to its type by 'argK_type'. For example: 110 // 111 // ACTION(IncrementArg1) { 112 // arg1_type temp = arg1; 113 // return ++(*temp); 114 // } 115 // 116 // allows you to write 117 // 118 // ...WillOnce(IncrementArg1()); 119 // 120 // You can also refer to the entire argument tuple and its type by 121 // 'args' and 'args_type', and refer to the mock function type and its 122 // return type by 'function_type' and 'return_type'. 123 // 124 // Note that you don't need to specify the types of the mock function 125 // arguments. However rest assured that your code is still type-safe: 126 // you'll get a compiler error if *arg1 doesn't support the ++ 127 // operator, or if the type of ++(*arg1) isn't compatible with the 128 // mock function's return type, for example. 129 // 130 // Sometimes you'll want to parameterize the action. For that you can use 131 // another macro: 132 // 133 // ACTION_P(name, param_name) { statements; } 134 // 135 // For example: 136 // 137 // ACTION_P(Add, n) { return arg0 + n; } 138 // 139 // will allow you to write: 140 // 141 // ...WillOnce(Add(5)); 142 // 143 // Note that you don't need to provide the type of the parameter 144 // either. If you need to reference the type of a parameter named 145 // 'foo', you can write 'foo_type'. For example, in the body of 146 // ACTION_P(Add, n) above, you can write 'n_type' to refer to the type 147 // of 'n'. 148 // 149 // We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support 150 // multi-parameter actions. 151 // 152 // For the purpose of typing, you can view 153 // 154 // ACTION_Pk(Foo, p1, ..., pk) { ... } 155 // 156 // as shorthand for 157 // 158 // template <typename p1_type, ..., typename pk_type> 159 // FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } 160 // 161 // In particular, you can provide the template type arguments 162 // explicitly when invoking Foo(), as in Foo<long, bool>(5, false); 163 // although usually you can rely on the compiler to infer the types 164 // for you automatically. You can assign the result of expression 165 // Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., 166 // pk_type>. This can be useful when composing actions. 167 // 168 // You can also overload actions with different numbers of parameters: 169 // 170 // ACTION_P(Plus, a) { ... } 171 // ACTION_P2(Plus, a, b) { ... } 172 // 173 // While it's tempting to always use the ACTION* macros when defining 174 // a new action, you should also consider implementing ActionInterface 175 // or using MakePolymorphicAction() instead, especially if you need to 176 // use the action a lot. While these approaches require more work, 177 // they give you more control on the types of the mock function 178 // arguments and the action parameters, which in general leads to 179 // better compiler error messages that pay off in the long run. They 180 // also allow overloading actions based on parameter types (as opposed 181 // to just based on the number of parameters). 182 // 183 // CAVEAT: 184 // 185 // ACTION*() can only be used in a namespace scope. The reason is 186 // that C++ doesn't yet allow function-local types to be used to 187 // instantiate templates. The up-coming C++0x standard will fix this. 188 // Once that's done, we'll consider supporting using ACTION*() inside 189 // a function. 190 // 191 // MORE INFORMATION: 192 // 193 // To learn more about using these macros, please search for 'ACTION' on 194 // https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md 195 196 $range i 0..n 197 $range k 0..n-1 198 199 // An internal macro needed for implementing ACTION*(). 200 #define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ 201 const args_type& args GTEST_ATTRIBUTE_UNUSED_ 202 $for k [[, \ 203 arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]] 204 205 206 // Sometimes you want to give an action explicit template parameters 207 // that cannot be inferred from its value parameters. ACTION() and 208 // ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that 209 // and can be viewed as an extension to ACTION() and ACTION_P*(). 210 // 211 // The syntax: 212 // 213 // ACTION_TEMPLATE(ActionName, 214 // HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), 215 // AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } 216 // 217 // defines an action template that takes m explicit template 218 // parameters and n value parameters. name_i is the name of the i-th 219 // template parameter, and kind_i specifies whether it's a typename, 220 // an integral constant, or a template. p_i is the name of the i-th 221 // value parameter. 222 // 223 // Example: 224 // 225 // // DuplicateArg<k, T>(output) converts the k-th argument of the mock 226 // // function to type T and copies it to *output. 227 // ACTION_TEMPLATE(DuplicateArg, 228 // HAS_2_TEMPLATE_PARAMS(int, k, typename, T), 229 // AND_1_VALUE_PARAMS(output)) { 230 // *output = T(::std::get<k>(args)); 231 // } 232 // ... 233 // int n; 234 // EXPECT_CALL(mock, Foo(_, _)) 235 // .WillOnce(DuplicateArg<1, unsigned char>(&n)); 236 // 237 // To create an instance of an action template, write: 238 // 239 // ActionName<t1, ..., t_m>(v1, ..., v_n) 240 // 241 // where the ts are the template arguments and the vs are the value 242 // arguments. The value argument types are inferred by the compiler. 243 // If you want to explicitly specify the value argument types, you can 244 // provide additional template arguments: 245 // 246 // ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) 247 // 248 // where u_i is the desired type of v_i. 249 // 250 // ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the 251 // number of value parameters, but not on the number of template 252 // parameters. Without the restriction, the meaning of the following 253 // is unclear: 254 // 255 // OverloadedAction<int, bool>(x); 256 // 257 // Are we using a single-template-parameter action where 'bool' refers 258 // to the type of x, or are we using a two-template-parameter action 259 // where the compiler is asked to infer the type of x? 260 // 261 // Implementation notes: 262 // 263 // GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and 264 // GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for 265 // implementing ACTION_TEMPLATE. The main trick we use is to create 266 // new macro invocations when expanding a macro. For example, we have 267 // 268 // #define ACTION_TEMPLATE(name, template_params, value_params) 269 // ... GMOCK_INTERNAL_DECL_##template_params ... 270 // 271 // which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) 272 // to expand to 273 // 274 // ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... 275 // 276 // Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the 277 // preprocessor will continue to expand it to 278 // 279 // ... typename T ... 280 // 281 // This technique conforms to the C++ standard and is portable. It 282 // allows us to implement action templates using O(N) code, where N is 283 // the maximum number of template/value parameters supported. Without 284 // using it, we'd have to devote O(N^2) amount of code to implement all 285 // combinations of m and n. 286 287 // Declares the template parameters. 288 289 $range j 1..n 290 $for j [[ 291 $range m 0..j-1 292 #define GMOCK_INTERNAL_DECL_HAS_$j[[]] 293 _TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]] 294 295 296 ]] 297 298 // Lists the template parameters. 299 300 $for j [[ 301 $range m 0..j-1 302 #define GMOCK_INTERNAL_LIST_HAS_$j[[]] 303 _TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]] 304 305 306 ]] 307 308 // Declares the types of value parameters. 309 310 $for i [[ 311 $range j 0..i-1 312 #define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]] 313 _VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]] 314 315 316 ]] 317 318 // Initializes the value parameters. 319 320 $for i [[ 321 $range j 0..i-1 322 #define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\ 323 ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(::std::move(gmock_p$j))]] 324 325 326 ]] 327 328 // Declares the fields for storing the value parameters. 329 330 $for i [[ 331 $range j 0..i-1 332 #define GMOCK_INTERNAL_DEFN_AND_$i[[]] 333 _VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]] 334 335 336 ]] 337 338 // Lists the value parameters. 339 340 $for i [[ 341 $range j 0..i-1 342 #define GMOCK_INTERNAL_LIST_AND_$i[[]] 343 _VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]] 344 345 346 ]] 347 348 // Lists the value parameter types. 349 350 $for i [[ 351 $range j 0..i-1 352 #define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]] 353 _VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]] 354 355 356 ]] 357 358 // Declares the value parameters. 359 360 $for i [[ 361 $range j 0..i-1 362 #define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] 363 $for j, [[p$j##_type p$j]] 364 365 366 ]] 367 368 // The suffix of the class template implementing the action template. 369 $for i [[ 370 371 372 $range j 0..i-1 373 #define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] 374 $if i==1 [[P]] $elif i>=2 [[P$i]] 375 ]] 376 377 378 // The name of the class template implementing the action template. 379 #define GMOCK_ACTION_CLASS_(name, value_params)\ 380 GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) 381 382 $range k 0..n-1 383 384 #define ACTION_TEMPLATE(name, template_params, value_params)\ 385 template <GMOCK_INTERNAL_DECL_##template_params\ 386 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 387 class GMOCK_ACTION_CLASS_(name, value_params) {\ 388 public:\ 389 explicit GMOCK_ACTION_CLASS_(name, value_params)\ 390 GMOCK_INTERNAL_INIT_##value_params {}\ 391 template <typename F>\ 392 class gmock_Impl : public ::testing::ActionInterface<F> {\ 393 public:\ 394 typedef F function_type;\ 395 typedef typename ::testing::internal::Function<F>::Result return_type;\ 396 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 397 args_type;\ 398 explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ 399 virtual return_type Perform(const args_type& args) {\ 400 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 401 Perform(this, args);\ 402 }\ 403 template <$for k, [[typename arg$k[[]]_type]]>\ 404 return_type gmock_PerformImpl(const args_type& args[[]] 405 $for k [[, arg$k[[]]_type arg$k]]) const;\ 406 GMOCK_INTERNAL_DEFN_##value_params\ 407 private:\ 408 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 409 };\ 410 template <typename F> operator ::testing::Action<F>() const {\ 411 return ::testing::Action<F>(\ 412 new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\ 413 }\ 414 GMOCK_INTERNAL_DEFN_##value_params\ 415 private:\ 416 GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ 417 };\ 418 template <GMOCK_INTERNAL_DECL_##template_params\ 419 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 420 inline GMOCK_ACTION_CLASS_(name, value_params)<\ 421 GMOCK_INTERNAL_LIST_##template_params\ 422 GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ 423 GMOCK_INTERNAL_DECL_##value_params) {\ 424 return GMOCK_ACTION_CLASS_(name, value_params)<\ 425 GMOCK_INTERNAL_LIST_##template_params\ 426 GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ 427 GMOCK_INTERNAL_LIST_##value_params);\ 428 }\ 429 template <GMOCK_INTERNAL_DECL_##template_params\ 430 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 431 template <typename F>\ 432 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 433 typename arg3_type, typename arg4_type, typename arg5_type, \ 434 typename arg6_type, typename arg7_type, typename arg8_type, \ 435 typename arg9_type>\ 436 typename ::testing::internal::Function<F>::Result\ 437 GMOCK_ACTION_CLASS_(name, value_params)<\ 438 GMOCK_INTERNAL_LIST_##template_params\ 439 GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\ 440 gmock_PerformImpl(\ 441 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 442 443 $for i 444 445 [[ 446 $var template = [[$if i==0 [[]] $else [[ 447 $range j 0..i-1 448 449 template <$for j, [[typename p$j##_type]]>\ 450 ]]]] 451 $var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]] 452 $else [[P$i]]]]]] 453 $range j 0..i-1 454 $var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] 455 $var param_types_and_names = [[$for j, [[p$j##_type p$j]]]] 456 $var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::forward<p$j##_type>(gmock_p$j))]]]]]] 457 $var param_field_decls = [[$for j 458 [[ 459 460 p$j##_type p$j;\ 461 ]]]] 462 $var param_field_decls2 = [[$for j 463 [[ 464 465 p$j##_type p$j;\ 466 ]]]] 467 $var params = [[$for j, [[p$j]]]] 468 $var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]] 469 $var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]] 470 $var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]] 471 $var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]] 472 $else [[ACTION_P$i]]]] 473 474 #define $macro_name(name$for j [[, p$j]])\$template 475 class $class_name {\ 476 public:\ 477 [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\ 478 template <typename F>\ 479 class gmock_Impl : public ::testing::ActionInterface<F> {\ 480 public:\ 481 typedef F function_type;\ 482 typedef typename ::testing::internal::Function<F>::Result return_type;\ 483 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 484 args_type;\ 485 [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\ 486 virtual return_type Perform(const args_type& args) {\ 487 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 488 Perform(this, args);\ 489 }\ 490 template <$typename_arg_types>\ 491 return_type gmock_PerformImpl(const args_type& args, [[]] 492 $arg_types_and_names) const;\$param_field_decls 493 private:\ 494 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 495 };\ 496 template <typename F> operator ::testing::Action<F>() const {\ 497 return ::testing::Action<F>(new gmock_Impl<F>($params));\ 498 }\$param_field_decls2 499 private:\ 500 GTEST_DISALLOW_ASSIGN_($class_name);\ 501 };\$template 502 inline $class_name$param_types name($param_types_and_names) {\ 503 return $class_name$param_types($params);\ 504 }\$template 505 template <typename F>\ 506 template <$typename_arg_types>\ 507 typename ::testing::internal::Function<F>::Result\ 508 $class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\ 509 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 510 ]] 511 $$ } // This meta comment fixes auto-indentation in Emacs. It won't 512 $$ // show up in the generated code. 513 514 515 namespace testing { 516 517 518 // The ACTION*() macros trigger warning C4100 (unreferenced formal 519 // parameter) in MSVC with -W4. Unfortunately they cannot be fixed in 520 // the macro definition, as the warnings are generated when the macro 521 // is expanded and macro expansion cannot contain #pragma. Therefore 522 // we suppress them here. 523 #ifdef _MSC_VER 524 # pragma warning(push) 525 # pragma warning(disable:4100) 526 #endif 527 528 // Various overloads for InvokeArgument<N>(). 529 // 530 // The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th 531 // (0-based) argument, which must be a k-ary callable, of the mock 532 // function, with arguments a1, a2, ..., a_k. 533 // 534 // Notes: 535 // 536 // 1. The arguments are passed by value by default. If you need to 537 // pass an argument by reference, wrap it inside ByRef(). For 538 // example, 539 // 540 // InvokeArgument<1>(5, string("Hello"), ByRef(foo)) 541 // 542 // passes 5 and string("Hello") by value, and passes foo by 543 // reference. 544 // 545 // 2. If the callable takes an argument by reference but ByRef() is 546 // not used, it will receive the reference to a copy of the value, 547 // instead of the original value. For example, when the 0-th 548 // argument of the mock function takes a const string&, the action 549 // 550 // InvokeArgument<0>(string("Hello")) 551 // 552 // makes a copy of the temporary string("Hello") object and passes a 553 // reference of the copy, instead of the original temporary object, 554 // to the callable. This makes it easy for a user to define an 555 // InvokeArgument action from temporary values and have it performed 556 // later. 557 558 namespace internal { 559 namespace invoke_argument { 560 561 // Appears in InvokeArgumentAdl's argument list to help avoid 562 // accidental calls to user functions of the same name. 563 struct AdlTag {}; 564 565 // InvokeArgumentAdl - a helper for InvokeArgument. 566 // The basic overloads are provided here for generic functors. 567 // Overloads for other custom-callables are provided in the 568 // internal/custom/callback-actions.h header. 569 570 $range i 0..n 571 $for i 572 [[ 573 $range j 1..i 574 575 template <typename R, typename F[[$for j [[, typename A$j]]]]> 576 R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) { 577 return f([[$for j, [[a$j]]]]); 578 } 579 ]] 580 581 } // namespace invoke_argument 582 } // namespace internal 583 584 $range i 0..n 585 $for i [[ 586 $range j 0..i-1 587 588 ACTION_TEMPLATE(InvokeArgument, 589 HAS_1_TEMPLATE_PARAMS(int, k), 590 AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) { 591 using internal::invoke_argument::InvokeArgumentAdl; 592 return InvokeArgumentAdl<return_type>( 593 internal::invoke_argument::AdlTag(), 594 ::std::get<k>(args)$for j [[, p$j]]); 595 } 596 597 ]] 598 599 // Various overloads for ReturnNew<T>(). 600 // 601 // The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new 602 // instance of type T, constructed on the heap with constructor arguments 603 // a1, a2, ..., and a_k. The caller assumes ownership of the returned value. 604 $range i 0..n 605 $for i [[ 606 $range j 0..i-1 607 $var ps = [[$for j, [[p$j]]]] 608 609 ACTION_TEMPLATE(ReturnNew, 610 HAS_1_TEMPLATE_PARAMS(typename, T), 611 AND_$i[[]]_VALUE_PARAMS($ps)) { 612 return new T($ps); 613 } 614 615 ]] 616 617 #ifdef _MSC_VER 618 # pragma warning(pop) 619 #endif 620 621 } // namespace testing 622 623 // Include any custom callback actions added by the local installation. 624 // We must include this header at the end to make sure it can use the 625 // declarations from this file. 626 #include "gmock/internal/custom/gmock-generated-actions.h" 627 628 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 629