Can Google Mock a method with a smart pointer return type?

by

A feasible workaround for google mock framework’s problems with non (const) copyable function arguments and retun values is to use proxy mock methods.

Suppose you have the following interface definition (if it’s good style to use std::unique_ptr in this way seems to be more or less a philosophical question, I personally like it to enforce transfer of ownership):

class IFooInterface {
public:
    virtual void nonCopyableParam(std::unique_ptr<IMyObjectThing> uPtr) = 0;
    virtual std::unique_ptr<IMyObjectThing> nonCopyableReturn() = 0;
    virtual ~IFooInterface() {}
};

The appropriate mock class could be defined like this:

class FooInterfaceMock
: public IFooInterface {
public:
    FooInterfaceMock() {}
    virtual ~FooInterfaceMock() {}

    virtual void nonCopyableParam(std::unique_ptr<IMyObjectThing> uPtr) {
        nonCopyableParamProxy(uPtr.get());
    }
    virtual std::unique_ptr<IMyObjectThing> nonCopyableReturn() {
        return std::unique_ptr<IMyObjectThing>(nonCopyableReturnProxy());
    }


    MOCK_METHOD1(nonCopyableParamProxy,void (IMyObjectThing*));
    MOCK_METHOD0(nonCopyableReturnProxy,IMyObjectThing* ());
};

You just need to take care, that configurations (Actions taken) for the nonCopyableReturnProxy() method return either NULL or an instance allocated dynamically on the heap.

There’s a google-mock user forum thread discussing this topic where one of the maintainers states that the google-mock framework won’t be changed to support this in future arguing that their policies strongly discourage the usage std::auto_ptr parameters. As mentioned this is IMHO a philosophical point of view, and the capabilities of the mocking framework shouldn’t steer what kind of interfaces you want to design or you can use from 3rd party APIs.

As said the answer describes a feasible workaround.

More Related Contents:

  1. Mocking free function
  2. Dependency injection with unique_ptr to mock
  3. google mock – can I call EXPECT_CALL multiple times on same mock object?
  4. What is a smart pointer and when should I use one?
  5. RAII and smart pointers in C++
  6. Which kind of pointer do I use when?
  7. Why can I not push_back a unique_ptr into a vector?
  8. Differences between std::make_unique and std::unique_ptr with new
  9. What C++ Smart Pointer Implementations are available?
  10. “Downcasting” unique_ptr to unique_ptr
  11. How to set up Google C++ Testing Framework (gtest) with Visual Studio 2005
  12. Comparison of C++ unit test frameworks [closed]
  13. How much is the overhead of smart pointers compared to normal pointers in C++?
  14. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  15. C++ unit testing framework [closed]
  16. How to set up googleTest as a shared library on Linux
  17. How to avoid memory leak with shared_ptr?
  18. When to use shared_ptr and when to use raw pointers?
  19. Passing shared_ptr as shared_ptr
  20. Should I delete the move constructor and the move assignment of a smart pointer?
  21. Return Type Covariance with Smart Pointers
  22. Can gmock be used for stubbing C functions?
  23. How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?
  24. Is auto_ptr deprecated?
  25. unique_ptr and OpenSSL’s STACK_OF(X509)*
  26. Why would I std::move an std::shared_ptr?
  27. CMake: Project structure with unit tests
  28. Comparison of arrays in google test?
  29. Example to use shared_ptr?
  30. C++11: Replace all non-owning raw pointers with std::shared_ptr()?

Leave a Comment