Overriding linking in Cpp to point to mocked implementation - c++

Question

I need to mock some classes using GoogleMock and change the base class implementation so that it creates actually an instance of this mocked one.
The base class is generated automatically along with some other classes that don't need to be mocked and all added in the same library.
The classes that need to be mocked are created through a factory, through which i intend to return the child class.
Can i "relink" with this new library which has implementation for already linked base class?
What i hope to achieve is get the instance of the base class from the unit-under-test and then cast it up to the mocked one.
Code example:
Original.hpp
class Base
{
private:
Base();
public:
virtual ~Base();
static std::shared_ptr<Base> createInstance();
}
Original.cpp
#include "Original.hpp"
...
std::shared_ptr<Base> Base::createInstance()
{
return std::shared_ptr<Base>(new Base());
}
...
Modified.hpp
class Derived : public Base
.....
Modified.cpp
#include "Original.hpp"
#include "Modified.hpp"
...
std::shared_ptr<Base> Base::createInstance()
{
return std::shared_ptr<Base>((Base*) new Derived());
}
So i want whenever the Base class is instantiated through createInstance anywhere in the project, the createInstance defined in Modified.cpp to be used instead, to return the Derived class.

Answer 1

OK, I think I understand more or less. If the library is already compiled you cannot change the implementation of that static factory method. If you provide your own implementation and try to link it with the existing lib you will have multiple definition (not allowed). What you can do is to add one layer to your application that will be responsible for this Base objects creation:
// existing implementation
class Base {
public:
virtual ~Base();
static std::shared_ptr<Base> createInstance() {
return std::shared_ptr<Base>(new Base());
}
private:
Base() {};
};
// new layer, part of your production code
class IYourFactory {
public:
virtual ~IYourFactory() = default;
virtual std::shared_ptr<Base> createInstance() = 0;
};
// new layer, part of your production code
class ProductionFactory: public IYourFactory {
public:
~ProductionFactory() override = default;
std::shared_ptr<Base> createInstance() override {
return Base::createInstance();
}
};
// testing code, you can use GMock to create this class
class MockBase: public Base {
public:
// it's a hack for Base private default constructor
MockBase(): Base(*Base::createInstance()) {}
~MockBase() override = default;
};
// testing code, you can use GMock to create this class
class MockFactory: public IYourFactory {
~MockFactory() override = default;
std::shared_ptr<Base> createInstance() override {
return std::make_shared<MockBase>();
}
};
class YourSystem {
public:
YourSystem(std::shared_ptr<IYourFactory> factory): factory_(factory) {}
bool doSomeThings() {
auto basePtr = factory_->createInstance();
return true;
}
private:
std::shared_ptr<IYourFactory> factory_;
};
Of course it will only do the job if Base class has some virtual functions that you can override in your MockBase. If not, this is not the way to go (you will need to create your own interface for the methods offered by Base).
The exact solution depends on how you use it in your system and what is the interface to Base.