EXPECT_CALL(mock, f(N)) vs f(K) followed by f(N) - c++

Question

I'm trying to understand how EXPECT_CALLs work and I'm stuck with a strange behavior (in my opinion strange). Let's say my code does this (let's assume there is a mock and f(int) is it's method, also let's assume that SomeNiceMock is a NiceMock):
void SomeMock::f(int) { ... }
NiceMock<SomeMock> someNiceMock;
void runCycle(int n) { someNiceMock.f(n); }
Now if in test I will do the following
EXPECT_CALL(someNiceMock, f(2)).Times(AtLeast(1));
runCycle(1);
runCycle(2);
::testing::Mock::VerifyAndClearExpectations(&mock);
I'm getting an error that f(int) was assumed to be called with 2 but was called with 1.
Expected: to be called at least once
Actual: never called - unsatisfied and active
If I do it like so:
runCycle(1);
EXPECT_CALL(someNiceMock, f(2)).Times(AtLeast(1));
runCycle(2);
::testing::Mock::VerifyAndClearExpectations(&mock);
Everything works.
I can live with this behavior I just don't understand the reason behind it. someNiceMock is a NiceMock so it should not complain about f(int) being called with some other argument then expected as long as there was actually a call to f(int) with an expected argument. Second call runCycle(2) did call f(2). So why wasn't the call f(1) simply ignored and test failed? Is is so that if I specify an EXPECT_CALL even for a NiceMock if this call will be with a different argument (but later there will be another call with a proper argument) the test will fail? Isn't that counter-intuitive considering that this is a NiceMock and a call to f(2) actually happened in both cases?
EDIT: And how should I then test such behavior? Let's say I'm having some number generator and I want to test that when called 10 times it returns 5 at least 3 times (and I don't care about other results. I would expect to code it like so (sorry if I mess the syntax, I'm not that good at google mock):
struct INumberGeneratorSink {
virtual void consumeNumber(int number) = 0;
};
struct NumberGeneratorSink : public INumberGeneratorSink {
void consumeNumber(int number) override { ... }
};
struct NumberGeneratorSinkMock : public INumberGeneratorSink {
MOCK_METHOD1(consumeNumber, void(int number));
};
void numberGeneratorFunction(INumberGeneratorSink &sink)
{
for (int i = 0; i < 10; i++)
{
sink.consumeNumber(getNumberFromSomewhere());
}
}
NumberGeneratorSinkMock sinkMock;
NiceMock<NumberGeneratorSinkMock> niceSinkMock;
EXPECT_CALL(niceSinkMock, consumeNumber(5)).Times(AtLeast(3));
numberGeneratorFunction(niceSinkMock);
How am I suppose to code stuff like that? If there are some syntax error please correct me, but my question is more like - if I care only about that consumeNumber is called 3 times with value 5 and I don't care about the rest how can I code it? Do I have to write something like:
// not sure about syntax for Any(),
// maybe it doesn't exist and has to be AtLeast(1)
EXPECT_CALL(niceSinkMock, consumeNumber(_)).Times(Any());
EXPECT_CALL(niceSinkMock, consumeNumber(5)).Times(AtLeast(3));
Will that work? Won't first EXPECT_CALL just match everything and test will pass even if consumeNumber will never be called with 5 as argument?

Answer 1

I totally agree, gmock can be confusing concerning the expectations. ;-)
1) Why does the following fail?
EXPECT_CALL(someNiceMock, f(2)).Times(AtLeast(1));
runCycle(1);
runCycle(2);
If a mock method has no EXPECT_CALL but is called, Google Mock will print a warning. To suppress this warning, you can use a NiceMock. However, if an EXPECT_CALL exists, it will and should fail.
2) Why does the following pass?
runCycle(1);
EXPECT_CALL(someNiceMock, f(2)).Times(AtLeast(1));
runCycle(2);
Easy answer: The EXPECT_CALL has to be written before. But this way of writing tests should not be the usual way.
3) The Solution to handle multiple expectations
From the gmock cook book:
"By default, when a mock method is invoked, Google Mock will search the expectations in the reverse order they are defined, and stop when
an active expectation that matches the arguments is found"
Your last code snipped is almost right. The correct implementation of Times(Any()) is to omit it.
EXPECT_CALL(someNiceMock, f(_));
EXPECT_CALL(someNiceMock, f(2)).Times(1);
runCycle(1);
runCycle(2);
Also please notice, that your Mock "SomeMock" needs a "mocked" method.
E.g.:
class SomeMock {
public:
MOCK_CONST_METHOD1(f, void(int i));
};