How to use GMock check base class function is called - c++

Question

This is very closely related to How to use gmock to test that a class calls it's base class' methods but I'm struggling to get this working with my example.
I'm using GTest and GMock to test drive a new feature so I have a base class...
class SimpleObject
{
public:
explicit SimpleObject() {}
virtual void moveX(int dX)
{
// Do important stuff like updating position, bounding box etc.
}
// ...
};
Based on other TDD I have a derived class and the new feature is such that when I call moveX on the derived object it will do something specific, however it also needs to do the important stuff in SimpleObject::moveX.
I already have test driven unit tests related to the SimpleObject::moveX function so I don't want to repeat them for the derived class. As long as I know SimpleObject::moveX is called then everything's hunky dory.
Anyway, based on the above link and following TDD I've ended up with the following.
The derived class:
class ComplexObject : public SimpleObject
{
public:
virtual void moveX(int dX)
{
// Do something specific
}
};
The 'testable' class:
class TestableComplexObject : public ComplexObject
{
public:
MOCK_METHOD1(moveX, void(int dX));
void doMoveX(int dX)
{
SimpleObject::moveX(dX);
}
};
The test:
TEST_F(ATestableComplexObject, CallsBaseClassMoveXWhenMoveXIsCalled)
{
int dX(8);
TestableComplexObject obj;
EXPECT_CALL(obj, moveX(dX))
.Times(1)
.WillRepeatedly(testing::Invoke(&obj, &TestableComplexObject::doMoveX));
obj.moveX(dX);
}
If I run my tests then everything passes. This isn't correct because as you can see ComplexObject::moveX doesn't do anything.
Also, regardless of what I put in doMoveX (which I thought was meant to set up my expectations) the tests will still pass.
I'm obviously missing something simple here, so any ideas?

Answer 1

Thanks for the comments, with a tweak to the design I am able to test what I want.
Firstly, create an interface for SimpleObject:
class ISimpleObject
{
public:
virtual void moveX(int dX) = 0;
};
My SimpleObject class then implements this:
class SimpleObject : public ISimpleObject
{
public:
explicit SimpleObject() {}
virtual void moveX(int dX)
{
(void) dX;
// Do important stuff like updating position, bounding box etc.
}
};
Instead of ComplexObject inheriting from SimpleObject, it inherits from the interface and owns a SimpleObject (i.e. it 'has a' rather than 'is a'). The constructor ensures we pass in a SimpleObject and it's this injection that makes mocking easier.
class ComplexObject : public ISimpleObject
{
public:
ComplexObject(SimpleObject *obj)
{
_obj = obj;
}
virtual void moveX(int dX)
{
_obj->moveX(dX);
}
private:
SimpleObject *_obj;
};
Now I simply mock the calls I'm interested in from SimpleObject
class SimpleObjectMock : public SimpleObject
{
public:
MOCK_METHOD1(moveX, void(int dX));
// Do important stuff like updating position, bounding box etc.
};
The test is simplified too
TEST_F(AComplexObject, CallsBaseClassMoveXWhenMoveX)
{
int dX(8);
SimpleObjectMock mock;
ComplexObject obj(&mock);
EXPECT_CALL(mock, moveX(dX)).Times(1);
obj.moveX(dX);
}
The behaviour is as expected. If the ComplexObject::moveX function is empty (as it will be at the start) then the test fails. It will only pass when you call SimpleObject::moveX.

Answer 2

You need to design your ComplexObject in a way that checking if SimpleObject::moveX was called is possible. One way to do it: encapsulate this base call with some other function that can be mocked:
class ComplexObject : public SimpleObject
{
public:
virtual void moveX(int dX)
{
// Call base function
baseMoveX(dx);
// Do something specific
}
protected:
virtual void baseMoveX(int dX)
{
SimpleObject::moveX(dx);
}
};
Then in your Testable class just mock this base function:
class TestableComplexObject : public ComplexObject
{
public:
MOCK_METHOD1(baseMoveX, void(int dX));
};
You cannot mock just moveX because - there is no way to distinguish between base and derived in such context.
So - your test can look like this:
TEST_F(ATestableComplexObject, CallsBaseClassMoveXWhenMoveXIsCalled)
{
int dX(8);
TestableComplexObject obj;
EXPECT_CALL(obj, baseMoveX(dX))
.WillOnce(testing::Invoke([&obj] (auto dx) {obj.SimpleObject::moveX(dx); }));
obj.moveX();
}
[UPDATE]
As it is discovered in comments - there is still a problem how to ensure ComplexObject::baseMoveX() calls SimpleObject::moveX.
The possible solution is to put one more class in between ComplexObject and SimpleObject.
template <typename BaseObject>
class IntermediateObject : public BaseObject
{
public:
virtual void baseMoveX(int dX)
{
BaseObject::moveX(dx);
}
};
With test ensuring this really happens:
class TestableBaseMock
{
public:
MOCK_METHOD1(moveX, void(int dX));
};
TEST(IntermediateObject Test, shallCallBaseMoveX)
{
const int dX = 8;
IntermediateObject<TestableBaseMock> objectUnderTest;
TestableBaseMock& baseMock = objectUnderTest;
EXPECT_CALL(baseMock, moveX(dX));
objectUnderTest.baseMoveX(dx);
}
Then - put it between Simple and Complex classes:
class ComplexObject : public IntermediateObject<SimpleObject>
{
public:
virtual void moveX(int dX)
{
// Call base function
baseMoveX(dx);
// Do something specific
}
};
At the end - I just want to emphasize that changing your original design - to use aggregation instead of inheritance (aka decorator design pattern) is the best way. First - as you can see in my answer - trying to stay with inheritance make the design worse if we want to test it. Second - tests for decorator kind of design are much simpler as it showed in one of the answers...

Answer 3

The main issue here is that, in method TestableComplexObject::doMoveX, you are calling method SimpleObject::moveX. This is why everything passes. You are supposed to call the method moveX that belongs to class ComplexObject. Therefore, changing method doMoveX to:
void doMoveX(int dX)
{
ComplexObject::moveX(dX);
}
will solve your problem.
There is one more issue with the code you've posted. The last statement in the test body should be:
obj.moveX(dX);
but I guess this is just an error made while writing the question?
Hope this helps!