1. GoogleMock for Dummies

2. Outline What is Mock? What Is Google C++ Mocking Framework?
Getting Started
A Case for Mock Turtles
Writing the Mock Class
Using Mocks in Tests
Setting Expectations
Appendix
Reference

3. What is Mock?
We creates a mock object to test the behavior of some other object
An object that we want to mock has the following characteristics:
Supplies non-deterministic results (e.g. the current time).
Has states that are difficult to create or reproduce (e.g. a network error).
Is slow (e.g. a complete database, which would have to be initialized before the test).
Does not yet exist or may change behavior.
Would have to include information and methods exclusively for testing purposes (and not for its actual task).

4. What is Mock?
For example, crash test dummy is a mock object used to simulate the dynamic behavior of a human in vehicle impacts

5. What Is Google C++ Mocking Framework?
A mock object implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do
Which methods will be called?
In which order?
How many times?
With what arguments?
What will they return?

6. What Is Google C++ Mocking Framework?
A mock allows you to check the interaction between itself and code that uses it
Google C++ Mocking Framework is a library for creating mock classes and using them

7. What Is Google C++ Mocking Framework?
Using Google Mock involves three basic steps:
Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class
Create some mock objects and specify its expectations and behavior using an intuitive syntax
Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises

8. Getting Started #include <gtest/gtest.h>
#include <gmock/gmock.h>

9. A Case for Mock Turtles
Suppose you are developing a graphics program that relies on a API (say, Turtle) for drawing
Run your program and compare the screen with a golden screen snapshot to see if it does the right thing
What if the API has been upgraded? Re-run your program and compare the screen with a up-to-date golden screen snapshot?
Instead of having your application talk to the drawing API directly, wrap the API in an interface and code to that interface

10. A Case for Mock Turtles void foo(int i, char c) { ……
// bar object is not maintained by
// your team
bar.method(i); }
void foo(int i, char c) { ……
// we can see how our function
// interact with bar object
mock_bar.method(i); }

11. Getting Started
This is the API we want to mock

12. Writing the Mock Class - How to Define It
Here are the simple steps you need to follow:
Derive a class MockTurtle from Turtle.
Take a virtual function of Turtle. Count how many arguments it has.
Inside the child class, write MOCK_METHODn()/MOCK_CONST_METHODn();, where n is the number of the arguments.
Cut-and-paste the function name as the first argument to the macro, and leave what's left as the second argument.
Repeat until all virtual functions you want to mock are done.
How about non-virtual function then? Overload function? Class template?
See

13. Writing the Mock Class - How to Define It
After the process, you should have something like:

14. Writing the Mock Class - How to Define It

15. Writing the Mock Class - Where to Put It
Put the mock’s definition in mock_xxx.h so that anyone want to use the mock only need to include mock_xxx.h

16. Using Mocks in Tests The typical work flow is:
Import the Google Mock names from the testing namespace such that you can use them unqualified.
Create some mock objects.
Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.

17. Our painter object will use Turtle object to do the drawing.
Using Mocks in Tests
We expect that PenDown() is called at least once.
Our painter object will use Turtle object to do the drawing.
googletest assertion

18. Setting Expectations
The key to using a mock object successfully is to set the right expectations on it
Too strict or too loose expectation is not good

19. Setting Expectations - General Syntax
use the EXPECT_CALL() macro to set an expectation on a mock method
Two arguments: first the mock object, and then the method and its arguments
Note that the two are separated by a comma
It’s a comma
Optional clauses that provide more information about the expectation.

20. Setting Expectations - General Syntax
The turtle object's GetX() method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time

21. Matchers - What Arguments Do We Expect?
When a mock function takes arguments, we must specify what arguments we are expecting
Matchers are more flexible
A matcher is like a predicate and can test whether an argument is what we'd expect
Maybe too strict?
A list of built-in matchers can be found on

22. Cardinalities - How Many Times Will It Be Called?
Times() is a clause can be specified follows an EXPECT_CALL()
We call its argument a cardinality as it tells how many times the call should occur
Times(cardinality) can:
Repeat an expectation many times.
A cardinality can be "fuzzy", just like a matcher can be.

23. Cardinalities - How Many Times Will It Be Called?
Google Mock will report a Google Test failure whenever the function is (wrongfully) called
AtLeast(n)
An example of fuzzy cardinalities. The call is expected at least n times.
If Times() ommitted, Google Mock will infer the cardinality
If neither WillOnce() nor WillRepeatedly() is in the EXPECT_CALL(), the inferred cardinality is Times(1).
If there are n WillOnce()'s but no WillRepeatedly(), where n >= 1, the cardinality is Times(n).
If there are n WillOnce()'s and one WillRepeatedly(), where n >= 0, the cardinality is Times(AtLeast(n)).

24. Cardinalities - How Many Times Will It Be Called?
How do Google Mock infer the cardinality?
WillRepeatedly()
WillOnce()
None
one
Times(1)
n ≥ 1
Times(n)
n ≥ 0
Times(AtLeast(n))

25. Actions - What Should It Do?
If the return type of a mock function is a built-in type or a pointer, the function has a default action. If you don't say anything, this behavior will be used
void function will just return.
bool function will return false.
Other functions will return 0.
Say something

26. Actions - What Should It Do?
If a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of WillOnce() clauses followed by an optional WillRepeatedly()

27. Actions - What Should It Do?

28. Actions - What Should It Do?

29. Actions - What Should It Do?
What can we do inside WillOnce() besides Return()? You can return a reference using ReturnRef(variable), or invoke a pre-defined function
Invoke pre-defined function
See

30. Actions - What Should It Do?
EXPECT_CALL() statement evaluates the action clause only once, even though the action may be performed many times

31. Actions - What Should It Do?
Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as n++ is only evaluated once, which means it will return 100, 0, 0, 0
turtle.GetY() will return 100 the first time, but return 0 from the second time on, as returning 0 is the default action for int functions
Postfix increment

32. Using Multiple Expectations
Specify expectations on multiple mock methods, which may be from multiple mock objects
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
Newer rules override older ones!

33. Using Multiple Expectations
If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure
If Forward(10) is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated

34. Using Multiple Expectations
Match in the reverse order?
This allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body
Put the one with more specific matchers after the other

35. Ordered vs Unordered Calls
The calls don't have to occur in the order the expectations are specified
Want all the expected calls to occur in a strict order?
Creating an object of type InSequence
Want to specify partial order?
See

36. All Expectations Are Sticky
Test that the turtle is asked to go to the origin exactly twice. What if GOTO(0, 0) called 3 times?
Expectations in Google Mock are "sticky" by default, in the sense that they remain active even after we have reached their invocation upper bounds

37. All Expectations Are Sticky
turtle.GetX() will be called n times and will return 10, 20, 30, ..., consecutively?
The second time turtle.GetX() is called, the last (latest) EXPECT_CALL() statement will match. It’s a "upper bound exceeded" error!

38. All Expectations Are Sticky
How to make expectation not sticky?
Use RetiresOnSaturation()
turtle.GetX() will return 10, 20, 30, ...
It should retire as soon as it is saturated.

39. All Expectations Are Sticky
The other situation where an expectation may not be sticky is when it's in a sequence
As soon as another expectation that comes after it in the sequence has been used, it automatically retires

40. Uninteresting Calls
In Google Mock, if you are not interested in a method, just don't say anything about it
If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure

41. Appendix - Mocks and fakes
Fakes implement the same interface as the object that they represent and returning pre-arranged responses
Mocks do a little more. They will examine the context of each call
Checking the order in which its methods are called.
Performing tests on the data passed into the method calls as arguments.

42. Appendix - Mocks and fakes
Fake objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
Mocks are objects pre-programmed with expectations, which form a specification of the calls they are expected to receive

43. Reference http://code.google.com/p/googlemock/wiki/ForDummies