How to stub/mock a const function - c++

Question

I want to count the number of calls to a certain function in class A, made by another function in class B. This is done in a class test for class B, and in this test class A is stubbed.
Here I try to explain the involved classes in terms of C++ code:
class X
{
const void Method() const = 0;
}
class A : public X
{
const void Method() const;
}
class AStub : public A
{
const void Method() const;
U32 getNumberOfCallsToMethod();
}
class B
{
void runAlgorithm();
A* getA(); // returns pointer to the A instance used by B
}
class BTest
{
void test_runAlgorithm()
{
B b;
// b is setup to use a stub of A rather than A..
// ...
U32 before = ((AStub*)b.getA())->getNumberOfCallsToMethod();
b.runAlgorithm();
U32 after = ((AStub*)b.getA())->getNumberOfCallsToMethod();
// Verify that Method() has been run exactly once
ASSERT_EQUAL("Unexpected number of calls to Method()",
before + 1, after);
}
}
Now to my problem. How do i override Method() in my stub with a "dummy" variant that counts number of calls? I have the dummy in place and it is called as intended, but i cannot make it increment a counter because it is declared const. I would like to add a counter to my AStub and have AStub::Method() increase the counter as part of the dummy implementation, but this seems tricky given the way it is declared.
I cannot use any mocking frameworks like google mock or similar, but there has to be some common solution to this issue. How would one normally go about this little hurdle?
Thanks

Answer 1

If you are using inheritance, you'll probably need to declare Method as virtual:
class X
{
virtual void Method() const = 0;
};
(Also removed const void, as it makes no sense - const after the member function is sufficient to make it a const function)
Then use the mutable keyword to tell the compiler "I want this particular member variable to be able t change even when in a const call" - call this variable numCalls, adding a default constructor to zero numCalls.
class AStub : public A
{
public:
AStub() : numCalls(0) {}
void Method() const;
U32 getNumberOfCallsToMethod();
private:
mutable U32 numCalls;
}
Finally, do the implementation of Method which increments number of calls and then calls the original function:
void AStub::Method() const
{
numCalls++;
A::Method();
}

Answer 2

If the question is how to modify a member variable in a const method, then the answer is quite simple : use the mutable keyword.
Something like this should work :
class AStub : public A
{
public:
const void Method() const{ ++n; }
mutable int n;
};

Answer 3

You can use a mocking framework to do the job for you. No need to implement your own mock class (AStub).
Here is how you do it with Fake-It. A simple mocking framework for C++:
class X
{
public:
virtual const void foo() const = 0;
};
class A : public X
{
public:
virtual const void foo() const override {}
};
class B
{
A& _a;
public:
B(A& a):_a(a){}
void runAlgorithm() { _a.foo(); }
A& getA() { return _a; }
};
A a;
Mock<A> mock(a);
Spy(Method(mock,foo)); // Spy A::foo on the mock object.
// Instantiate B (class under test) and inject the mock instance.
B b(mock.get());
// Run the tested method.
b.runAlgorithm();
// Verify the A::foo of the injected object was invoked exactly once.
Verify(Method(mock,foo)).Exactly(Once);