Google Mock
The Google C++ mocking framework.
Overview
Google's framework for writing and using C++ mock classes. It can help you derive better designs of your system and write better tests.
It is inspired by:
and designed with C++'s specifics in mind.
Google mock:
- lets you create mock classes trivially using simple macros.
- supports a rich set of matchers and actions.
- handles unordered, partially ordered, or completely ordered expectations.
- is extensible by users.
We hope you find it useful!
Features
- Provides a declarative syntax for defining mocks.
- Can easily define partial (hybrid) mocks, which are a cross of real and mock objects.
- Handles functions of arbitrary types and overloaded functions.
- Comes with a rich set of matchers for validating function arguments.
- Uses an intuitive syntax for controlling the behavior of a mock.
- Does automatic verification of expectations (no record-and-replay needed).
- Allows arbitrary (partial) ordering constraints on function calls to be expressed,.
- Lets a user extend it by defining new matchers and actions.
- Does not use exceptions.
- Is easy to learn and use.
Please see the project page above for more information as well as the mailing list for questions, discussions, and development. There is also an IRC channel on OFTC (irc.oftc.net) #gtest available. Please join us!
Please note that code under scripts/generator is from cppclean and released under the Apache License, which is different from Google Mock's license.
Getting Started
If you are new to the project, we suggest that you read the user documentation in the following order:
- Learn the basics of Google Test, if you choose to use Google Mock with it (recommended).
- Read Google Mock for Dummies.
- Read the instructions below on how to build Google Mock.
You can also watch Zhanyong's talk on Google Mock's usage and implementation.
Once you understand the basics, check out the rest of the docs:
- CheatSheet - all the commonly used stuff at a glance.
- CookBook - recipes for getting things done, including advanced techniques.
If you need help, please check the KnownIssues and FrequentlyAskedQuestions before posting a question on the discussion group.
Using Google Mock Without Google Test
Google Mock is not a testing framework itself. Instead, it needs a testing framework for writing tests. Google Mock works seamlessly with Google Test, but you can also use it with any C++ testing framework.
Requirements for End Users
Google Mock is implemented on top of Google Test, and depends on it. You must use the bundled version of Google Test when using Google Mock.
You can also easily configure Google Mock to work with another testing framework, although it will still need Google Test. Please read "Using_Google_Mock_with_Any_Testing_Framework" for instructions.
Google Mock depends on advanced C++ features and thus requires a more modern compiler. The following are needed to use Google Mock:
Linux Requirements
- GNU-compatible Make or "gmake"
- POSIX-standard shell
- POSIX(-2) Regular Expressions (regex.h)
- C++98-standard-compliant compiler (e.g. GCC 3.4 or newer)
Windows Requirements
- Microsoft Visual C++ 8.0 SP1 or newer
Mac OS X Requirements
- Mac OS X 10.4 Tiger or newer
- Developer Tools Installed
Requirements for Contributors
We welcome patches. If you plan to contribute a patch, you need to build Google Mock and its tests, which has further requirements:
- Automake version 1.9 or newer
- Autoconf version 2.59 or newer
- Libtool / Libtoolize
- Python version 2.3 or newer (for running some of the tests and re-generating certain source files from templates)
Building Google Mock
Using CMake
If you have CMake available, it is recommended that you follow the build instructions as described for Google Test.
If are using Google Mock with an existing CMake project, the section Incorporating Into An Existing CMake Project may be of particular interest. To make it work for Google Mock you will need to change
target_link_libraries(example gtest_main)
to
target_link_libraries(example gmock_main)
This works because gmock_main library is compiled with Google Test.
Tweaking Google Mock
Google Mock can be used in diverse environments. The default
configuration may not work (or may not work well) out of the box in
some environments. However, you can easily tweak Google Mock by
defining control macros on the compiler command line. Generally,
these macros are named like GTEST_XYZ and you define them to either 1
or 0 to enable or disable a certain feature.
We list the most frequently used macros below. For a complete list, see file ${GTEST_DIR}/include/gtest/internal/gtest-port.h.
As a Shared Library (DLL)
Google Mock is compact, so most users can build and link it as a static library for the simplicity. Google Mock can be used as a DLL, but the same DLL must contain Google Test as well. See Google Test's README for instructions on how to set up necessary compiler settings.
Tweaking Google Mock
Most of Google Test's control macros apply to Google Mock as well. Please see Google Test's README for how to tweak them.
Upgrading from an Earlier Version
We strive to keep Google Mock releases backward compatible. Sometimes, though, we have to make some breaking changes for the users' long-term benefits. This section describes what you'll need to do if you are upgrading from an earlier version of Google Mock.
Upgrading from 1.1.0 or Earlier
You may need to explicitly enable or disable Google Test's own TR1 tuple library. See the instructions in section "Choosing a TR1 Tuple Library".
Upgrading from 1.4.0 or Earlier
On platforms where the pthread library is available, Google Test and Google Mock use it in order to be thread-safe. For this to work, you may need to tweak your compiler and/or linker flags. Please see the "Multi-threaded Tests" section in file Google Test's README for what you may need to do.
If you have custom matchers defined using MatcherInterface or
MakePolymorphicMatcher(), you'll need to update their definitions to
use the new matcher API (
monomorphic,
polymorphic).
Matchers defined using MATCHER() or MATCHER_P*() aren't affected.
Happy testing!