1// Copyright 2007, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29// 30// Author: wan@google.com (Zhanyong Wan) 31 32// Google Mock - a framework for writing C++ mock classes. 33// 34// This file implements some commonly used actions. 35 36#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 37#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 38 39#include <algorithm> 40#include <string> 41 42#ifndef _WIN32_WCE 43# include <errno.h> 44#endif 45 46#include "gmock/internal/gmock-internal-utils.h" 47#include "gmock/internal/gmock-port.h" 48 49namespace testing { 50 51// To implement an action Foo, define: 52// 1. a class FooAction that implements the ActionInterface interface, and 53// 2. a factory function that creates an Action object from a 54// const FooAction*. 55// 56// The two-level delegation design follows that of Matcher, providing 57// consistency for extension developers. It also eases ownership 58// management as Action objects can now be copied like plain values. 59 60namespace internal { 61 62template <typename F1, typename F2> 63class ActionAdaptor; 64 65// BuiltInDefaultValue<T>::Get() returns the "built-in" default 66// value for type T, which is NULL when T is a pointer type, 0 when T 67// is a numeric type, false when T is bool, or "" when T is string or 68// std::string. For any other type T, this value is undefined and the 69// function will abort the process. 70template <typename T> 71class BuiltInDefaultValue { 72 public: 73 // This function returns true iff type T has a built-in default value. 74 static bool Exists() { return false; } 75 static T Get() { 76 Assert(false, __FILE__, __LINE__, 77 "Default action undefined for the function return type."); 78 return internal::Invalid<T>(); 79 // The above statement will never be reached, but is required in 80 // order for this function to compile. 81 } 82}; 83 84// This partial specialization says that we use the same built-in 85// default value for T and const T. 86template <typename T> 87class BuiltInDefaultValue<const T> { 88 public: 89 static bool Exists() { return BuiltInDefaultValue<T>::Exists(); } 90 static T Get() { return BuiltInDefaultValue<T>::Get(); } 91}; 92 93// This partial specialization defines the default values for pointer 94// types. 95template <typename T> 96class BuiltInDefaultValue<T*> { 97 public: 98 static bool Exists() { return true; } 99 static T* Get() { return NULL; } 100}; 101 102// The following specializations define the default values for 103// specific types we care about. 104#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \ 105 template <> \ 106 class BuiltInDefaultValue<type> { \ 107 public: \ 108 static bool Exists() { return true; } \ 109 static type Get() { return value; } \ 110 } 111 112GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT 113#if GTEST_HAS_GLOBAL_STRING 114GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, ""); 115#endif // GTEST_HAS_GLOBAL_STRING 116GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, ""); 117GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false); 118GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0'); 119GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0'); 120GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0'); 121 122// There's no need for a default action for signed wchar_t, as that 123// type is the same as wchar_t for gcc, and invalid for MSVC. 124// 125// There's also no need for a default action for unsigned wchar_t, as 126// that type is the same as unsigned int for gcc, and invalid for 127// MSVC. 128#if GMOCK_WCHAR_T_IS_NATIVE_ 129GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT 130#endif 131 132GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT 133GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT 134GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); 135GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); 136GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT 137GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT 138GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(UInt64, 0); 139GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0); 140GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); 141GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); 142 143#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ 144 145} // namespace internal 146 147// When an unexpected function call is encountered, Google Mock will 148// let it return a default value if the user has specified one for its 149// return type, or if the return type has a built-in default value; 150// otherwise Google Mock won't know what value to return and will have 151// to abort the process. 152// 153// The DefaultValue<T> class allows a user to specify the 154// default value for a type T that is both copyable and publicly 155// destructible (i.e. anything that can be used as a function return 156// type). The usage is: 157// 158// // Sets the default value for type T to be foo. 159// DefaultValue<T>::Set(foo); 160template <typename T> 161class DefaultValue { 162 public: 163 // Sets the default value for type T; requires T to be 164 // copy-constructable and have a public destructor. 165 static void Set(T x) { 166 delete value_; 167 value_ = new T(x); 168 } 169 170 // Unsets the default value for type T. 171 static void Clear() { 172 delete value_; 173 value_ = NULL; 174 } 175 176 // Returns true iff the user has set the default value for type T. 177 static bool IsSet() { return value_ != NULL; } 178 179 // Returns true if T has a default return value set by the user or there 180 // exists a built-in default value. 181 static bool Exists() { 182 return IsSet() || internal::BuiltInDefaultValue<T>::Exists(); 183 } 184 185 // Returns the default value for type T if the user has set one; 186 // otherwise returns the built-in default value if there is one; 187 // otherwise aborts the process. 188 static T Get() { 189 return value_ == NULL ? 190 internal::BuiltInDefaultValue<T>::Get() : *value_; 191 } 192 private: 193 static const T* value_; 194}; 195 196// This partial specialization allows a user to set default values for 197// reference types. 198template <typename T> 199class DefaultValue<T&> { 200 public: 201 // Sets the default value for type T&. 202 static void Set(T& x) { // NOLINT 203 address_ = &x; 204 } 205 206 // Unsets the default value for type T&. 207 static void Clear() { 208 address_ = NULL; 209 } 210 211 // Returns true iff the user has set the default value for type T&. 212 static bool IsSet() { return address_ != NULL; } 213 214 // Returns true if T has a default return value set by the user or there 215 // exists a built-in default value. 216 static bool Exists() { 217 return IsSet() || internal::BuiltInDefaultValue<T&>::Exists(); 218 } 219 220 // Returns the default value for type T& if the user has set one; 221 // otherwise returns the built-in default value if there is one; 222 // otherwise aborts the process. 223 static T& Get() { 224 return address_ == NULL ? 225 internal::BuiltInDefaultValue<T&>::Get() : *address_; 226 } 227 private: 228 static T* address_; 229}; 230 231// This specialization allows DefaultValue<void>::Get() to 232// compile. 233template <> 234class DefaultValue<void> { 235 public: 236 static bool Exists() { return true; } 237 static void Get() {} 238}; 239 240// Points to the user-set default value for type T. 241template <typename T> 242const T* DefaultValue<T>::value_ = NULL; 243 244// Points to the user-set default value for type T&. 245template <typename T> 246T* DefaultValue<T&>::address_ = NULL; 247 248// Implement this interface to define an action for function type F. 249template <typename F> 250class ActionInterface { 251 public: 252 typedef typename internal::Function<F>::Result Result; 253 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 254 255 ActionInterface() {} 256 virtual ~ActionInterface() {} 257 258 // Performs the action. This method is not const, as in general an 259 // action can have side effects and be stateful. For example, a 260 // get-the-next-element-from-the-collection action will need to 261 // remember the current element. 262 virtual Result Perform(const ArgumentTuple& args) = 0; 263 264 private: 265 GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface); 266}; 267 268// An Action<F> is a copyable and IMMUTABLE (except by assignment) 269// object that represents an action to be taken when a mock function 270// of type F is called. The implementation of Action<T> is just a 271// linked_ptr to const ActionInterface<T>, so copying is fairly cheap. 272// Don't inherit from Action! 273// 274// You can view an object implementing ActionInterface<F> as a 275// concrete action (including its current state), and an Action<F> 276// object as a handle to it. 277template <typename F> 278class Action { 279 public: 280 typedef typename internal::Function<F>::Result Result; 281 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 282 283 // Constructs a null Action. Needed for storing Action objects in 284 // STL containers. 285 Action() : impl_(NULL) {} 286 287 // Constructs an Action from its implementation. A NULL impl is 288 // used to represent the "do-default" action. 289 explicit Action(ActionInterface<F>* impl) : impl_(impl) {} 290 291 // Copy constructor. 292 Action(const Action& action) : impl_(action.impl_) {} 293 294 // This constructor allows us to turn an Action<Func> object into an 295 // Action<F>, as long as F's arguments can be implicitly converted 296 // to Func's and Func's return type can be implicitly converted to 297 // F's. 298 template <typename Func> 299 explicit Action(const Action<Func>& action); 300 301 // Returns true iff this is the DoDefault() action. 302 bool IsDoDefault() const { return impl_.get() == NULL; } 303 304 // Performs the action. Note that this method is const even though 305 // the corresponding method in ActionInterface is not. The reason 306 // is that a const Action<F> means that it cannot be re-bound to 307 // another concrete action, not that the concrete action it binds to 308 // cannot change state. (Think of the difference between a const 309 // pointer and a pointer to const.) 310 Result Perform(const ArgumentTuple& args) const { 311 internal::Assert( 312 !IsDoDefault(), __FILE__, __LINE__, 313 "You are using DoDefault() inside a composite action like " 314 "DoAll() or WithArgs(). This is not supported for technical " 315 "reasons. Please instead spell out the default action, or " 316 "assign the default action to an Action variable and use " 317 "the variable in various places."); 318 return impl_->Perform(args); 319 } 320 321 private: 322 template <typename F1, typename F2> 323 friend class internal::ActionAdaptor; 324 325 internal::linked_ptr<ActionInterface<F> > impl_; 326}; 327 328// The PolymorphicAction class template makes it easy to implement a 329// polymorphic action (i.e. an action that can be used in mock 330// functions of than one type, e.g. Return()). 331// 332// To define a polymorphic action, a user first provides a COPYABLE 333// implementation class that has a Perform() method template: 334// 335// class FooAction { 336// public: 337// template <typename Result, typename ArgumentTuple> 338// Result Perform(const ArgumentTuple& args) const { 339// // Processes the arguments and returns a result, using 340// // tr1::get<N>(args) to get the N-th (0-based) argument in the tuple. 341// } 342// ... 343// }; 344// 345// Then the user creates the polymorphic action using 346// MakePolymorphicAction(object) where object has type FooAction. See 347// the definition of Return(void) and SetArgumentPointee<N>(value) for 348// complete examples. 349template <typename Impl> 350class PolymorphicAction { 351 public: 352 explicit PolymorphicAction(const Impl& impl) : impl_(impl) {} 353 354 template <typename F> 355 operator Action<F>() const { 356 return Action<F>(new MonomorphicImpl<F>(impl_)); 357 } 358 359 private: 360 template <typename F> 361 class MonomorphicImpl : public ActionInterface<F> { 362 public: 363 typedef typename internal::Function<F>::Result Result; 364 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 365 366 explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} 367 368 virtual Result Perform(const ArgumentTuple& args) { 369 return impl_.template Perform<Result>(args); 370 } 371 372 private: 373 Impl impl_; 374 375 GTEST_DISALLOW_ASSIGN_(MonomorphicImpl); 376 }; 377 378 Impl impl_; 379 380 GTEST_DISALLOW_ASSIGN_(PolymorphicAction); 381}; 382 383// Creates an Action from its implementation and returns it. The 384// created Action object owns the implementation. 385template <typename F> 386Action<F> MakeAction(ActionInterface<F>* impl) { 387 return Action<F>(impl); 388} 389 390// Creates a polymorphic action from its implementation. This is 391// easier to use than the PolymorphicAction<Impl> constructor as it 392// doesn't require you to explicitly write the template argument, e.g. 393// 394// MakePolymorphicAction(foo); 395// vs 396// PolymorphicAction<TypeOfFoo>(foo); 397template <typename Impl> 398inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) { 399 return PolymorphicAction<Impl>(impl); 400} 401 402namespace internal { 403 404// Allows an Action<F2> object to pose as an Action<F1>, as long as F2 405// and F1 are compatible. 406template <typename F1, typename F2> 407class ActionAdaptor : public ActionInterface<F1> { 408 public: 409 typedef typename internal::Function<F1>::Result Result; 410 typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple; 411 412 explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {} 413 414 virtual Result Perform(const ArgumentTuple& args) { 415 return impl_->Perform(args); 416 } 417 418 private: 419 const internal::linked_ptr<ActionInterface<F2> > impl_; 420 421 GTEST_DISALLOW_ASSIGN_(ActionAdaptor); 422}; 423 424// Implements the polymorphic Return(x) action, which can be used in 425// any function that returns the type of x, regardless of the argument 426// types. 427// 428// Note: The value passed into Return must be converted into 429// Function<F>::Result when this action is cast to Action<F> rather than 430// when that action is performed. This is important in scenarios like 431// 432// MOCK_METHOD1(Method, T(U)); 433// ... 434// { 435// Foo foo; 436// X x(&foo); 437// EXPECT_CALL(mock, Method(_)).WillOnce(Return(x)); 438// } 439// 440// In the example above the variable x holds reference to foo which leaves 441// scope and gets destroyed. If copying X just copies a reference to foo, 442// that copy will be left with a hanging reference. If conversion to T 443// makes a copy of foo, the above code is safe. To support that scenario, we 444// need to make sure that the type conversion happens inside the EXPECT_CALL 445// statement, and conversion of the result of Return to Action<T(U)> is a 446// good place for that. 447// 448template <typename R> 449class ReturnAction { 450 public: 451 // Constructs a ReturnAction object from the value to be returned. 452 // 'value' is passed by value instead of by const reference in order 453 // to allow Return("string literal") to compile. 454 explicit ReturnAction(R value) : value_(value) {} 455 456 // This template type conversion operator allows Return(x) to be 457 // used in ANY function that returns x's type. 458 template <typename F> 459 operator Action<F>() const { 460 // Assert statement belongs here because this is the best place to verify 461 // conditions on F. It produces the clearest error messages 462 // in most compilers. 463 // Impl really belongs in this scope as a local class but can't 464 // because MSVC produces duplicate symbols in different translation units 465 // in this case. Until MS fixes that bug we put Impl into the class scope 466 // and put the typedef both here (for use in assert statement) and 467 // in the Impl class. But both definitions must be the same. 468 typedef typename Function<F>::Result Result; 469 GTEST_COMPILE_ASSERT_( 470 !internal::is_reference<Result>::value, 471 use_ReturnRef_instead_of_Return_to_return_a_reference); 472 return Action<F>(new Impl<F>(value_)); 473 } 474 475 private: 476 // Implements the Return(x) action for a particular function type F. 477 template <typename F> 478 class Impl : public ActionInterface<F> { 479 public: 480 typedef typename Function<F>::Result Result; 481 typedef typename Function<F>::ArgumentTuple ArgumentTuple; 482 483 // The implicit cast is necessary when Result has more than one 484 // single-argument constructor (e.g. Result is std::vector<int>) and R 485 // has a type conversion operator template. In that case, value_(value) 486 // won't compile as the compiler doesn't known which constructor of 487 // Result to call. ImplicitCast_ forces the compiler to convert R to 488 // Result without considering explicit constructors, thus resolving the 489 // ambiguity. value_ is then initialized using its copy constructor. 490 explicit Impl(R value) 491 : value_(::testing::internal::ImplicitCast_<Result>(value)) {} 492 493 virtual Result Perform(const ArgumentTuple&) { return value_; } 494 495 private: 496 GTEST_COMPILE_ASSERT_(!internal::is_reference<Result>::value, 497 Result_cannot_be_a_reference_type); 498 Result value_; 499 500 GTEST_DISALLOW_ASSIGN_(Impl); 501 }; 502 503 R value_; 504 505 GTEST_DISALLOW_ASSIGN_(ReturnAction); 506}; 507 508// Implements the ReturnNull() action. 509class ReturnNullAction { 510 public: 511 // Allows ReturnNull() to be used in any pointer-returning function. 512 template <typename Result, typename ArgumentTuple> 513 static Result Perform(const ArgumentTuple&) { 514 GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value, 515 ReturnNull_can_be_used_to_return_a_pointer_only); 516 return NULL; 517 } 518}; 519 520// Implements the Return() action. 521class ReturnVoidAction { 522 public: 523 // Allows Return() to be used in any void-returning function. 524 template <typename Result, typename ArgumentTuple> 525 static void Perform(const ArgumentTuple&) { 526 CompileAssertTypesEqual<void, Result>(); 527 } 528}; 529 530// Implements the polymorphic ReturnRef(x) action, which can be used 531// in any function that returns a reference to the type of x, 532// regardless of the argument types. 533template <typename T> 534class ReturnRefAction { 535 public: 536 // Constructs a ReturnRefAction object from the reference to be returned. 537 explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT 538 539 // This template type conversion operator allows ReturnRef(x) to be 540 // used in ANY function that returns a reference to x's type. 541 template <typename F> 542 operator Action<F>() const { 543 typedef typename Function<F>::Result Result; 544 // Asserts that the function return type is a reference. This 545 // catches the user error of using ReturnRef(x) when Return(x) 546 // should be used, and generates some helpful error message. 547 GTEST_COMPILE_ASSERT_(internal::is_reference<Result>::value, 548 use_Return_instead_of_ReturnRef_to_return_a_value); 549 return Action<F>(new Impl<F>(ref_)); 550 } 551 552 private: 553 // Implements the ReturnRef(x) action for a particular function type F. 554 template <typename F> 555 class Impl : public ActionInterface<F> { 556 public: 557 typedef typename Function<F>::Result Result; 558 typedef typename Function<F>::ArgumentTuple ArgumentTuple; 559 560 explicit Impl(T& ref) : ref_(ref) {} // NOLINT 561 562 virtual Result Perform(const ArgumentTuple&) { 563 return ref_; 564 } 565 566 private: 567 T& ref_; 568 569 GTEST_DISALLOW_ASSIGN_(Impl); 570 }; 571 572 T& ref_; 573 574 GTEST_DISALLOW_ASSIGN_(ReturnRefAction); 575}; 576 577// Implements the polymorphic ReturnRefOfCopy(x) action, which can be 578// used in any function that returns a reference to the type of x, 579// regardless of the argument types. 580template <typename T> 581class ReturnRefOfCopyAction { 582 public: 583 // Constructs a ReturnRefOfCopyAction object from the reference to 584 // be returned. 585 explicit ReturnRefOfCopyAction(const T& value) : value_(value) {} // NOLINT 586 587 // This template type conversion operator allows ReturnRefOfCopy(x) to be 588 // used in ANY function that returns a reference to x's type. 589 template <typename F> 590 operator Action<F>() const { 591 typedef typename Function<F>::Result Result; 592 // Asserts that the function return type is a reference. This 593 // catches the user error of using ReturnRefOfCopy(x) when Return(x) 594 // should be used, and generates some helpful error message. 595 GTEST_COMPILE_ASSERT_( 596 internal::is_reference<Result>::value, 597 use_Return_instead_of_ReturnRefOfCopy_to_return_a_value); 598 return Action<F>(new Impl<F>(value_)); 599 } 600 601 private: 602 // Implements the ReturnRefOfCopy(x) action for a particular function type F. 603 template <typename F> 604 class Impl : public ActionInterface<F> { 605 public: 606 typedef typename Function<F>::Result Result; 607 typedef typename Function<F>::ArgumentTuple ArgumentTuple; 608 609 explicit Impl(const T& value) : value_(value) {} // NOLINT 610 611 virtual Result Perform(const ArgumentTuple&) { 612 return value_; 613 } 614 615 private: 616 T value_; 617 618 GTEST_DISALLOW_ASSIGN_(Impl); 619 }; 620 621 const T value_; 622 623 GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction); 624}; 625 626// Implements the polymorphic DoDefault() action. 627class DoDefaultAction { 628 public: 629 // This template type conversion operator allows DoDefault() to be 630 // used in any function. 631 template <typename F> 632 operator Action<F>() const { return Action<F>(NULL); } 633}; 634 635// Implements the Assign action to set a given pointer referent to a 636// particular value. 637template <typename T1, typename T2> 638class AssignAction { 639 public: 640 AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {} 641 642 template <typename Result, typename ArgumentTuple> 643 void Perform(const ArgumentTuple& /* args */) const { 644 *ptr_ = value_; 645 } 646 647 private: 648 T1* const ptr_; 649 const T2 value_; 650 651 GTEST_DISALLOW_ASSIGN_(AssignAction); 652}; 653 654#if !GTEST_OS_WINDOWS_MOBILE 655 656// Implements the SetErrnoAndReturn action to simulate return from 657// various system calls and libc functions. 658template <typename T> 659class SetErrnoAndReturnAction { 660 public: 661 SetErrnoAndReturnAction(int errno_value, T result) 662 : errno_(errno_value), 663 result_(result) {} 664 template <typename Result, typename ArgumentTuple> 665 Result Perform(const ArgumentTuple& /* args */) const { 666 errno = errno_; 667 return result_; 668 } 669 670 private: 671 const int errno_; 672 const T result_; 673 674 GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction); 675}; 676 677#endif // !GTEST_OS_WINDOWS_MOBILE 678 679// Implements the SetArgumentPointee<N>(x) action for any function 680// whose N-th argument (0-based) is a pointer to x's type. The 681// template parameter kIsProto is true iff type A is ProtocolMessage, 682// proto2::Message, or a sub-class of those. 683template <size_t N, typename A, bool kIsProto> 684class SetArgumentPointeeAction { 685 public: 686 // Constructs an action that sets the variable pointed to by the 687 // N-th function argument to 'value'. 688 explicit SetArgumentPointeeAction(const A& value) : value_(value) {} 689 690 template <typename Result, typename ArgumentTuple> 691 void Perform(const ArgumentTuple& args) const { 692 CompileAssertTypesEqual<void, Result>(); 693 *::std::tr1::get<N>(args) = value_; 694 } 695 696 private: 697 const A value_; 698 699 GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction); 700}; 701 702template <size_t N, typename Proto> 703class SetArgumentPointeeAction<N, Proto, true> { 704 public: 705 // Constructs an action that sets the variable pointed to by the 706 // N-th function argument to 'proto'. Both ProtocolMessage and 707 // proto2::Message have the CopyFrom() method, so the same 708 // implementation works for both. 709 explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) { 710 proto_->CopyFrom(proto); 711 } 712 713 template <typename Result, typename ArgumentTuple> 714 void Perform(const ArgumentTuple& args) const { 715 CompileAssertTypesEqual<void, Result>(); 716 ::std::tr1::get<N>(args)->CopyFrom(*proto_); 717 } 718 719 private: 720 const internal::linked_ptr<Proto> proto_; 721 722 GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction); 723}; 724 725// Implements the InvokeWithoutArgs(f) action. The template argument 726// FunctionImpl is the implementation type of f, which can be either a 727// function pointer or a functor. InvokeWithoutArgs(f) can be used as an 728// Action<F> as long as f's type is compatible with F (i.e. f can be 729// assigned to a tr1::function<F>). 730template <typename FunctionImpl> 731class InvokeWithoutArgsAction { 732 public: 733 // The c'tor makes a copy of function_impl (either a function 734 // pointer or a functor). 735 explicit InvokeWithoutArgsAction(FunctionImpl function_impl) 736 : function_impl_(function_impl) {} 737 738 // Allows InvokeWithoutArgs(f) to be used as any action whose type is 739 // compatible with f. 740 template <typename Result, typename ArgumentTuple> 741 Result Perform(const ArgumentTuple&) { return function_impl_(); } 742 743 private: 744 FunctionImpl function_impl_; 745 746 GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction); 747}; 748 749// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action. 750template <class Class, typename MethodPtr> 751class InvokeMethodWithoutArgsAction { 752 public: 753 InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr) 754 : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {} 755 756 template <typename Result, typename ArgumentTuple> 757 Result Perform(const ArgumentTuple&) const { 758 return (obj_ptr_->*method_ptr_)(); 759 } 760 761 private: 762 Class* const obj_ptr_; 763 const MethodPtr method_ptr_; 764 765 GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction); 766}; 767 768// Implements the IgnoreResult(action) action. 769template <typename A> 770class IgnoreResultAction { 771 public: 772 explicit IgnoreResultAction(const A& action) : action_(action) {} 773 774 template <typename F> 775 operator Action<F>() const { 776 // Assert statement belongs here because this is the best place to verify 777 // conditions on F. It produces the clearest error messages 778 // in most compilers. 779 // Impl really belongs in this scope as a local class but can't 780 // because MSVC produces duplicate symbols in different translation units 781 // in this case. Until MS fixes that bug we put Impl into the class scope 782 // and put the typedef both here (for use in assert statement) and 783 // in the Impl class. But both definitions must be the same. 784 typedef typename internal::Function<F>::Result Result; 785 786 // Asserts at compile time that F returns void. 787 CompileAssertTypesEqual<void, Result>(); 788 789 return Action<F>(new Impl<F>(action_)); 790 } 791 792 private: 793 template <typename F> 794 class Impl : public ActionInterface<F> { 795 public: 796 typedef typename internal::Function<F>::Result Result; 797 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 798 799 explicit Impl(const A& action) : action_(action) {} 800 801 virtual void Perform(const ArgumentTuple& args) { 802 // Performs the action and ignores its result. 803 action_.Perform(args); 804 } 805 806 private: 807 // Type OriginalFunction is the same as F except that its return 808 // type is IgnoredValue. 809 typedef typename internal::Function<F>::MakeResultIgnoredValue 810 OriginalFunction; 811 812 const Action<OriginalFunction> action_; 813 814 GTEST_DISALLOW_ASSIGN_(Impl); 815 }; 816 817 const A action_; 818 819 GTEST_DISALLOW_ASSIGN_(IgnoreResultAction); 820}; 821 822// A ReferenceWrapper<T> object represents a reference to type T, 823// which can be either const or not. It can be explicitly converted 824// from, and implicitly converted to, a T&. Unlike a reference, 825// ReferenceWrapper<T> can be copied and can survive template type 826// inference. This is used to support by-reference arguments in the 827// InvokeArgument<N>(...) action. The idea was from "reference 828// wrappers" in tr1, which we don't have in our source tree yet. 829template <typename T> 830class ReferenceWrapper { 831 public: 832 // Constructs a ReferenceWrapper<T> object from a T&. 833 explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {} // NOLINT 834 835 // Allows a ReferenceWrapper<T> object to be implicitly converted to 836 // a T&. 837 operator T&() const { return *pointer_; } 838 private: 839 T* pointer_; 840}; 841 842// Allows the expression ByRef(x) to be printed as a reference to x. 843template <typename T> 844void PrintTo(const ReferenceWrapper<T>& ref, ::std::ostream* os) { 845 T& value = ref; 846 UniversalPrinter<T&>::Print(value, os); 847} 848 849// Does two actions sequentially. Used for implementing the DoAll(a1, 850// a2, ...) action. 851template <typename Action1, typename Action2> 852class DoBothAction { 853 public: 854 DoBothAction(Action1 action1, Action2 action2) 855 : action1_(action1), action2_(action2) {} 856 857 // This template type conversion operator allows DoAll(a1, ..., a_n) 858 // to be used in ANY function of compatible type. 859 template <typename F> 860 operator Action<F>() const { 861 return Action<F>(new Impl<F>(action1_, action2_)); 862 } 863 864 private: 865 // Implements the DoAll(...) action for a particular function type F. 866 template <typename F> 867 class Impl : public ActionInterface<F> { 868 public: 869 typedef typename Function<F>::Result Result; 870 typedef typename Function<F>::ArgumentTuple ArgumentTuple; 871 typedef typename Function<F>::MakeResultVoid VoidResult; 872 873 Impl(const Action<VoidResult>& action1, const Action<F>& action2) 874 : action1_(action1), action2_(action2) {} 875 876 virtual Result Perform(const ArgumentTuple& args) { 877 action1_.Perform(args); 878 return action2_.Perform(args); 879 } 880 881 private: 882 const Action<VoidResult> action1_; 883 const Action<F> action2_; 884 885 GTEST_DISALLOW_ASSIGN_(Impl); 886 }; 887 888 Action1 action1_; 889 Action2 action2_; 890 891 GTEST_DISALLOW_ASSIGN_(DoBothAction); 892}; 893 894} // namespace internal 895 896// An Unused object can be implicitly constructed from ANY value. 897// This is handy when defining actions that ignore some or all of the 898// mock function arguments. For example, given 899// 900// MOCK_METHOD3(Foo, double(const string& label, double x, double y)); 901// MOCK_METHOD3(Bar, double(int index, double x, double y)); 902// 903// instead of 904// 905// double DistanceToOriginWithLabel(const string& label, double x, double y) { 906// return sqrt(x*x + y*y); 907// } 908// double DistanceToOriginWithIndex(int index, double x, double y) { 909// return sqrt(x*x + y*y); 910// } 911// ... 912// EXEPCT_CALL(mock, Foo("abc", _, _)) 913// .WillOnce(Invoke(DistanceToOriginWithLabel)); 914// EXEPCT_CALL(mock, Bar(5, _, _)) 915// .WillOnce(Invoke(DistanceToOriginWithIndex)); 916// 917// you could write 918// 919// // We can declare any uninteresting argument as Unused. 920// double DistanceToOrigin(Unused, double x, double y) { 921// return sqrt(x*x + y*y); 922// } 923// ... 924// EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); 925// EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); 926typedef internal::IgnoredValue Unused; 927 928// This constructor allows us to turn an Action<From> object into an 929// Action<To>, as long as To's arguments can be implicitly converted 930// to From's and From's return type cann be implicitly converted to 931// To's. 932template <typename To> 933template <typename From> 934Action<To>::Action(const Action<From>& from) 935 : impl_(new internal::ActionAdaptor<To, From>(from)) {} 936 937// Creates an action that returns 'value'. 'value' is passed by value 938// instead of const reference - otherwise Return("string literal") 939// will trigger a compiler error about using array as initializer. 940template <typename R> 941internal::ReturnAction<R> Return(R value) { 942 return internal::ReturnAction<R>(value); 943} 944 945// Creates an action that returns NULL. 946inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() { 947 return MakePolymorphicAction(internal::ReturnNullAction()); 948} 949 950// Creates an action that returns from a void function. 951inline PolymorphicAction<internal::ReturnVoidAction> Return() { 952 return MakePolymorphicAction(internal::ReturnVoidAction()); 953} 954 955// Creates an action that returns the reference to a variable. 956template <typename R> 957inline internal::ReturnRefAction<R> ReturnRef(R& x) { // NOLINT 958 return internal::ReturnRefAction<R>(x); 959} 960 961// Creates an action that returns the reference to a copy of the 962// argument. The copy is created when the action is constructed and 963// lives as long as the action. 964template <typename R> 965inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) { 966 return internal::ReturnRefOfCopyAction<R>(x); 967} 968 969// Creates an action that does the default action for the give mock function. 970inline internal::DoDefaultAction DoDefault() { 971 return internal::DoDefaultAction(); 972} 973 974// Creates an action that sets the variable pointed by the N-th 975// (0-based) function argument to 'value'. 976template <size_t N, typename T> 977PolymorphicAction< 978 internal::SetArgumentPointeeAction< 979 N, T, internal::IsAProtocolMessage<T>::value> > 980SetArgPointee(const T& x) { 981 return MakePolymorphicAction(internal::SetArgumentPointeeAction< 982 N, T, internal::IsAProtocolMessage<T>::value>(x)); 983} 984 985#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN) 986// This overload allows SetArgPointee() to accept a string literal. 987// GCC prior to the version 4.0 and Symbian C++ compiler cannot distinguish 988// this overload from the templated version and emit a compile error. 989template <size_t N> 990PolymorphicAction< 991 internal::SetArgumentPointeeAction<N, const char*, false> > 992SetArgPointee(const char* p) { 993 return MakePolymorphicAction(internal::SetArgumentPointeeAction< 994 N, const char*, false>(p)); 995} 996 997template <size_t N> 998PolymorphicAction< 999 internal::SetArgumentPointeeAction<N, const wchar_t*, false> > 1000SetArgPointee(const wchar_t* p) { 1001 return MakePolymorphicAction(internal::SetArgumentPointeeAction< 1002 N, const wchar_t*, false>(p)); 1003} 1004#endif 1005 1006// The following version is DEPRECATED. 1007template <size_t N, typename T> 1008PolymorphicAction< 1009 internal::SetArgumentPointeeAction< 1010 N, T, internal::IsAProtocolMessage<T>::value> > 1011SetArgumentPointee(const T& x) { 1012 return MakePolymorphicAction(internal::SetArgumentPointeeAction< 1013 N, T, internal::IsAProtocolMessage<T>::value>(x)); 1014} 1015 1016// Creates an action that sets a pointer referent to a given value. 1017template <typename T1, typename T2> 1018PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) { 1019 return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val)); 1020} 1021 1022#if !GTEST_OS_WINDOWS_MOBILE 1023 1024// Creates an action that sets errno and returns the appropriate error. 1025template <typename T> 1026PolymorphicAction<internal::SetErrnoAndReturnAction<T> > 1027SetErrnoAndReturn(int errval, T result) { 1028 return MakePolymorphicAction( 1029 internal::SetErrnoAndReturnAction<T>(errval, result)); 1030} 1031 1032#endif // !GTEST_OS_WINDOWS_MOBILE 1033 1034// Various overloads for InvokeWithoutArgs(). 1035 1036// Creates an action that invokes 'function_impl' with no argument. 1037template <typename FunctionImpl> 1038PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> > 1039InvokeWithoutArgs(FunctionImpl function_impl) { 1040 return MakePolymorphicAction( 1041 internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl)); 1042} 1043 1044// Creates an action that invokes the given method on the given object 1045// with no argument. 1046template <class Class, typename MethodPtr> 1047PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> > 1048InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) { 1049 return MakePolymorphicAction( 1050 internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>( 1051 obj_ptr, method_ptr)); 1052} 1053 1054// Creates an action that performs an_action and throws away its 1055// result. In other words, it changes the return type of an_action to 1056// void. an_action MUST NOT return void, or the code won't compile. 1057template <typename A> 1058inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) { 1059 return internal::IgnoreResultAction<A>(an_action); 1060} 1061 1062// Creates a reference wrapper for the given L-value. If necessary, 1063// you can explicitly specify the type of the reference. For example, 1064// suppose 'derived' is an object of type Derived, ByRef(derived) 1065// would wrap a Derived&. If you want to wrap a const Base& instead, 1066// where Base is a base class of Derived, just write: 1067// 1068// ByRef<const Base>(derived) 1069template <typename T> 1070inline internal::ReferenceWrapper<T> ByRef(T& l_value) { // NOLINT 1071 return internal::ReferenceWrapper<T>(l_value); 1072} 1073 1074} // namespace testing 1075 1076#endif // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 1077