gmock-generated-actions.h.pump (21396B)
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 as templates cannot be 186 // declared inside of a local class. 187 // Users can, however, define any local functors (e.g. a lambda) that 188 // can be used as actions. 189 // 190 // MORE INFORMATION: 191 // 192 // To learn more about using these macros, please search for 'ACTION' on 193 // https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md 194 195 $range i 0..n 196 $range k 0..n-1 197 198 // An internal macro needed for implementing ACTION*(). 199 #define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ 200 const args_type& args GTEST_ATTRIBUTE_UNUSED_ 201 $for k [[, \ 202 const arg$k[[]]_type& arg$k GTEST_ATTRIBUTE_UNUSED_]] 203 204 205 // Sometimes you want to give an action explicit template parameters 206 // that cannot be inferred from its value parameters. ACTION() and 207 // ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that 208 // and can be viewed as an extension to ACTION() and ACTION_P*(). 209 // 210 // The syntax: 211 // 212 // ACTION_TEMPLATE(ActionName, 213 // HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), 214 // AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } 215 // 216 // defines an action template that takes m explicit template 217 // parameters and n value parameters. name_i is the name of the i-th 218 // template parameter, and kind_i specifies whether it's a typename, 219 // an integral constant, or a template. p_i is the name of the i-th 220 // value parameter. 221 // 222 // Example: 223 // 224 // // DuplicateArg<k, T>(output) converts the k-th argument of the mock 225 // // function to type T and copies it to *output. 226 // ACTION_TEMPLATE(DuplicateArg, 227 // HAS_2_TEMPLATE_PARAMS(int, k, typename, T), 228 // AND_1_VALUE_PARAMS(output)) { 229 // *output = T(::std::get<k>(args)); 230 // } 231 // ... 232 // int n; 233 // EXPECT_CALL(mock, Foo(_, _)) 234 // .WillOnce(DuplicateArg<1, unsigned char>(&n)); 235 // 236 // To create an instance of an action template, write: 237 // 238 // ActionName<t1, ..., t_m>(v1, ..., v_n) 239 // 240 // where the ts are the template arguments and the vs are the value 241 // arguments. The value argument types are inferred by the compiler. 242 // If you want to explicitly specify the value argument types, you can 243 // provide additional template arguments: 244 // 245 // ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) 246 // 247 // where u_i is the desired type of v_i. 248 // 249 // ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the 250 // number of value parameters, but not on the number of template 251 // parameters. Without the restriction, the meaning of the following 252 // is unclear: 253 // 254 // OverloadedAction<int, bool>(x); 255 // 256 // Are we using a single-template-parameter action where 'bool' refers 257 // to the type of x, or are we using a two-template-parameter action 258 // where the compiler is asked to infer the type of x? 259 // 260 // Implementation notes: 261 // 262 // GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and 263 // GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for 264 // implementing ACTION_TEMPLATE. The main trick we use is to create 265 // new macro invocations when expanding a macro. For example, we have 266 // 267 // #define ACTION_TEMPLATE(name, template_params, value_params) 268 // ... GMOCK_INTERNAL_DECL_##template_params ... 269 // 270 // which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) 271 // to expand to 272 // 273 // ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... 274 // 275 // Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the 276 // preprocessor will continue to expand it to 277 // 278 // ... typename T ... 279 // 280 // This technique conforms to the C++ standard and is portable. It 281 // allows us to implement action templates using O(N) code, where N is 282 // the maximum number of template/value parameters supported. Without 283 // using it, we'd have to devote O(N^2) amount of code to implement all 284 // combinations of m and n. 285 286 // Declares the template parameters. 287 288 $range j 1..n 289 $for j [[ 290 $range m 0..j-1 291 #define GMOCK_INTERNAL_DECL_HAS_$j[[]] 292 _TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]] 293 294 295 ]] 296 297 // Lists the template parameters. 298 299 $for j [[ 300 $range m 0..j-1 301 #define GMOCK_INTERNAL_LIST_HAS_$j[[]] 302 _TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]] 303 304 305 ]] 306 307 // Declares the types of value parameters. 308 309 $for i [[ 310 $range j 0..i-1 311 #define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]] 312 _VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]] 313 314 315 ]] 316 317 // Initializes the value parameters. 318 319 $for i [[ 320 $range j 0..i-1 321 #define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\ 322 ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(::std::move(gmock_p$j))]] 323 324 325 ]] 326 327 // Declares the fields for storing the value parameters. 328 329 $for i [[ 330 $range j 0..i-1 331 #define GMOCK_INTERNAL_DEFN_AND_$i[[]] 332 _VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]] 333 334 335 ]] 336 337 // Lists the value parameters. 338 339 $for i [[ 340 $range j 0..i-1 341 #define GMOCK_INTERNAL_LIST_AND_$i[[]] 342 _VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]] 343 344 345 ]] 346 347 // Lists the value parameter types. 348 349 $for i [[ 350 $range j 0..i-1 351 #define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]] 352 _VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]] 353 354 355 ]] 356 357 // Declares the value parameters. 358 359 $for i [[ 360 $range j 0..i-1 361 #define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] 362 $for j, [[p$j##_type p$j]] 363 364 365 ]] 366 367 // The suffix of the class template implementing the action template. 368 $for i [[ 369 370 371 $range j 0..i-1 372 #define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] 373 $if i==1 [[P]] $elif i>=2 [[P$i]] 374 ]] 375 376 377 // The name of the class template implementing the action template. 378 #define GMOCK_ACTION_CLASS_(name, value_params)\ 379 GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) 380 381 $range k 0..n-1 382 383 #define ACTION_TEMPLATE(name, template_params, value_params)\ 384 template <GMOCK_INTERNAL_DECL_##template_params\ 385 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 386 class GMOCK_ACTION_CLASS_(name, value_params) {\ 387 public:\ 388 explicit GMOCK_ACTION_CLASS_(name, value_params)\ 389 GMOCK_INTERNAL_INIT_##value_params {}\ 390 template <typename F>\ 391 class gmock_Impl : public ::testing::ActionInterface<F> {\ 392 public:\ 393 typedef F function_type;\ 394 typedef typename ::testing::internal::Function<F>::Result return_type;\ 395 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 396 args_type;\ 397 explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ 398 virtual return_type Perform(const args_type& args) {\ 399 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 400 Perform(this, args);\ 401 }\ 402 template <$for k, [[typename arg$k[[]]_type]]>\ 403 return_type gmock_PerformImpl(const args_type& args[[]] 404 $for k [[, const arg$k[[]]_type& arg$k]]) const;\ 405 GMOCK_INTERNAL_DEFN_##value_params\ 406 private:\ 407 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 408 };\ 409 template <typename F> operator ::testing::Action<F>() const {\ 410 return ::testing::Action<F>(\ 411 new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\ 412 }\ 413 GMOCK_INTERNAL_DEFN_##value_params\ 414 private:\ 415 GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ 416 };\ 417 template <GMOCK_INTERNAL_DECL_##template_params\ 418 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 419 inline GMOCK_ACTION_CLASS_(name, value_params)<\ 420 GMOCK_INTERNAL_LIST_##template_params\ 421 GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ 422 GMOCK_INTERNAL_DECL_##value_params) {\ 423 return GMOCK_ACTION_CLASS_(name, value_params)<\ 424 GMOCK_INTERNAL_LIST_##template_params\ 425 GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ 426 GMOCK_INTERNAL_LIST_##value_params);\ 427 }\ 428 template <GMOCK_INTERNAL_DECL_##template_params\ 429 GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 430 template <typename F>\ 431 template <typename arg0_type, typename arg1_type, typename arg2_type, \ 432 typename arg3_type, typename arg4_type, typename arg5_type, \ 433 typename arg6_type, typename arg7_type, typename arg8_type, \ 434 typename arg9_type>\ 435 typename ::testing::internal::Function<F>::Result\ 436 GMOCK_ACTION_CLASS_(name, value_params)<\ 437 GMOCK_INTERNAL_LIST_##template_params\ 438 GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\ 439 gmock_PerformImpl(\ 440 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 441 442 $for i 443 444 [[ 445 $var template = [[$if i==0 [[]] $else [[ 446 $range j 0..i-1 447 448 template <$for j, [[typename p$j##_type]]>\ 449 ]]]] 450 $var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]] 451 $else [[P$i]]]]]] 452 $range j 0..i-1 453 $var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] 454 $var param_types_and_names = [[$for j, [[p$j##_type p$j]]]] 455 $var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::forward<p$j##_type>(gmock_p$j))]]]]]] 456 $var param_field_decls = [[$for j 457 [[ 458 459 p$j##_type p$j;\ 460 ]]]] 461 $var param_field_decls2 = [[$for j 462 [[ 463 464 p$j##_type p$j;\ 465 ]]]] 466 $var params = [[$for j, [[p$j]]]] 467 $var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]] 468 $var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]] 469 $var arg_types_and_names = [[$for k, [[const arg$k[[]]_type& arg$k]]]] 470 $var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]] 471 $else [[ACTION_P$i]]]] 472 473 #define $macro_name(name$for j [[, p$j]])\$template 474 class $class_name {\ 475 public:\ 476 [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\ 477 template <typename F>\ 478 class gmock_Impl : public ::testing::ActionInterface<F> {\ 479 public:\ 480 typedef F function_type;\ 481 typedef typename ::testing::internal::Function<F>::Result return_type;\ 482 typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 483 args_type;\ 484 [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\ 485 virtual return_type Perform(const args_type& args) {\ 486 return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 487 Perform(this, args);\ 488 }\ 489 template <$typename_arg_types>\ 490 return_type gmock_PerformImpl(const args_type& args, [[]] 491 $arg_types_and_names) const;\$param_field_decls 492 private:\ 493 GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 494 };\ 495 template <typename F> operator ::testing::Action<F>() const {\ 496 return ::testing::Action<F>(new gmock_Impl<F>($params));\ 497 }\$param_field_decls2 498 private:\ 499 GTEST_DISALLOW_ASSIGN_($class_name);\ 500 };\$template 501 inline $class_name$param_types name($param_types_and_names) {\ 502 return $class_name$param_types($params);\ 503 }\$template 504 template <typename F>\ 505 template <$typename_arg_types>\ 506 typename ::testing::internal::Function<F>::Result\ 507 $class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\ 508 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 509 ]] 510 $$ } // This meta comment fixes auto-indentation in Emacs. It won't 511 $$ // show up in the generated code. 512 513 514 namespace testing { 515 516 517 // The ACTION*() macros trigger warning C4100 (unreferenced formal 518 // parameter) in MSVC with -W4. Unfortunately they cannot be fixed in 519 // the macro definition, as the warnings are generated when the macro 520 // is expanded and macro expansion cannot contain #pragma. Therefore 521 // we suppress them here. 522 #ifdef _MSC_VER 523 # pragma warning(push) 524 # pragma warning(disable:4100) 525 #endif 526 527 // Various overloads for InvokeArgument<N>(). 528 // 529 // The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th 530 // (0-based) argument, which must be a k-ary callable, of the mock 531 // function, with arguments a1, a2, ..., a_k. 532 // 533 // Notes: 534 // 535 // 1. The arguments are passed by value by default. If you need to 536 // pass an argument by reference, wrap it inside ByRef(). For 537 // example, 538 // 539 // InvokeArgument<1>(5, string("Hello"), ByRef(foo)) 540 // 541 // passes 5 and string("Hello") by value, and passes foo by 542 // reference. 543 // 544 // 2. If the callable takes an argument by reference but ByRef() is 545 // not used, it will receive the reference to a copy of the value, 546 // instead of the original value. For example, when the 0-th 547 // argument of the mock function takes a const string&, the action 548 // 549 // InvokeArgument<0>(string("Hello")) 550 // 551 // makes a copy of the temporary string("Hello") object and passes a 552 // reference of the copy, instead of the original temporary object, 553 // to the callable. This makes it easy for a user to define an 554 // InvokeArgument action from temporary values and have it performed 555 // later. 556 557 namespace internal { 558 namespace invoke_argument { 559 560 // Appears in InvokeArgumentAdl's argument list to help avoid 561 // accidental calls to user functions of the same name. 562 struct AdlTag {}; 563 564 // InvokeArgumentAdl - a helper for InvokeArgument. 565 // The basic overloads are provided here for generic functors. 566 // Overloads for other custom-callables are provided in the 567 // internal/custom/callback-actions.h header. 568 569 $range i 0..n 570 $for i 571 [[ 572 $range j 1..i 573 574 template <typename R, typename F[[$for j [[, typename A$j]]]]> 575 R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) { 576 return f([[$for j, [[a$j]]]]); 577 } 578 ]] 579 580 } // namespace invoke_argument 581 } // namespace internal 582 583 $range i 0..n 584 $for i [[ 585 $range j 0..i-1 586 587 ACTION_TEMPLATE(InvokeArgument, 588 HAS_1_TEMPLATE_PARAMS(int, k), 589 AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) { 590 using internal::invoke_argument::InvokeArgumentAdl; 591 return InvokeArgumentAdl<return_type>( 592 internal::invoke_argument::AdlTag(), 593 ::std::get<k>(args)$for j [[, p$j]]); 594 } 595 596 ]] 597 598 // Various overloads for ReturnNew<T>(). 599 // 600 // The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new 601 // instance of type T, constructed on the heap with constructor arguments 602 // a1, a2, ..., and a_k. The caller assumes ownership of the returned value. 603 $range i 0..n 604 $for i [[ 605 $range j 0..i-1 606 $var ps = [[$for j, [[p$j]]]] 607 608 ACTION_TEMPLATE(ReturnNew, 609 HAS_1_TEMPLATE_PARAMS(typename, T), 610 AND_$i[[]]_VALUE_PARAMS($ps)) { 611 return new T($ps); 612 } 613 614 ]] 615 616 #ifdef _MSC_VER 617 # pragma warning(pop) 618 #endif 619 620 } // namespace testing 621 622 // Include any custom callback actions added by the local installation. 623 // We must include this header at the end to make sure it can use the 624 // declarations from this file. 625 #include "gmock/internal/custom/gmock-generated-actions.h" 626 627 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_