how to use gtest
- ForDummies -- start here if you are new to Google Mock.
- CheatSheet -- a quick reference.
- CookBook -- recipes for doing various tasks using Google Mock.
- FrequentlyAskedQuestions -- check here before asking a question on the mailing list.
Mocking a Normal Class
以下類
class Foo { ... virtual ~Foo(); virtual int GetSize() const = 0; virtual string Describe(const char* name) = 0; virtual string Describe(int type) = 0; virtual bool Process(Bar elem, int count) = 0; };
(note that ~Foo()
must be virtual) we can define its mock as//析構函數得是虛函數
#include "gmock/gmock.h"
class MockFoo : public Foo {
MOCK_CONST_METHOD0(GetSize, int());//MOCK_CONST_METHOD0 第一個參數是函數名,第二個參數是描述返回值類型和形參類型 n表示函數的形參個數 0
MOCK_METHOD1(Describe, string(const char* name));返回值string 形參 const char *name,n = 1
MOCK_METHOD1(Describe, string(int type));
MOCK_METHOD2(Process, bool(Bar elem, int count));n = 2
};
Mocking a Class Template
如果你對模板有一定的瞭解,與class差不多
template <typename Elem> class StackInterface { public: ... virtual ~StackInterface(); virtual int GetSize() const = 0; virtual void Push(const Elem& x) = 0; };
(note that ~StackInterface()
must be virtual) just append _T
to the MOCK_*
macros:
template <typename Elem> class MockStack : public StackInterface<Elem> { public: ... MOCK_CONST_METHOD0_T(GetSize, int()); MOCK_METHOD1_T(Push, void(const Elem& x)); };
Specifying Calling Conventions for Mock Functions
指定模擬函數的調用規則
If your mock function doesn't use the default calling convention, you can specify it by appending _WITH_CALLTYPE
to any of the macros described in the previous two sections and supplying the calling convention as the first argument to the macro. For example,
如果你的模擬函數不適用默認的調用規則,可以添加_WITH_CALLTYPE
到任意一個前面提到的宏定義的後面來標識調用規則,並且提供第一個參數來標識具體的調用規則
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n)); MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
where STDMETHODCALLTYPE
is defined by <objbase.h>
on Windows.
Using Mocks in Tests
The typical flow is:
典型的流程:
- Import the Google Mock names you need to use. All Google Mock names are in the
testing
namespace unless they are macros or otherwise noted.
導入需要的Google Mock names。瞭解一下testing namespace
- Create the mock objects.
創建模擬對象
- Optionally, set the default actions of the mock objects.
選擇性的爲模擬對象建立默認操作
- Set your expectations on the mock objects (How will they be called? What wil they do?).
設置你的期望值//這一步比較關鍵,期望的運行時間,返回值,運行次數等等
- Exercise code that uses the mock objects; if necessary, check the result using Google Test assertions.
使用模擬對象的代碼, 並學會使用 G test的斷言來檢查結果
- When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
當一個模擬對象被析構, G test會自動驗證哪些需要滿足的期望。
Here is an example:
using ::testing::Return; // #1 TEST(BarTest, DoesThis) { MockFoo foo; // #2 ON_CALL(foo, GetSize()) // #3 .WillByDefault(Return(1)); // ... other default actions ... EXPECT_CALL(foo, Describe(5)) // #4 .Times(3) .WillRepeatedly(Return("Category 5")); // ... other expectations ... EXPECT_EQ("good", MyProductionFunction(&foo)); // #5 } // #6
Setting Default Actions
Google Mock has a built-in default action for any function that returns void
, bool
, a numeric value, or a pointer.
對於返回void、bool、數值或指針的任何函數,google mock都有內置的默認操作。
To customize the default action for functions with return type T
globally:
自定義返回值爲T的函數的默認操作:
using ::testing::DefaultValue; // Sets the default value to be returned. T must be CopyConstructible. DefaultValue<T>::Set(value); // Sets a factory. Will be invoked on demand. T must be MoveConstructible. // T MakeT(); DefaultValue<T>::SetFactory(&MakeT); // ... use the mocks ... // Resets the default value. DefaultValue<T>::Clear();
To customize the default action for a particular method, use ON_CALL()
:
ON_CALL(mock_object, method(matchers)) .With(multi_argument_matcher) ? .WillByDefault(action);
Setting Expectations
設置期望值
EXPECT_CALL()
sets expectations on a mock method (How will it be called? What will it do?):
EXPECT_CALL()
可以用來設置一個函數的期望值,比如期望怎麼被調用,會實現什麼?
EXPECT_CALL(mock_object, method(matchers)) .With(multi_argument_matcher) ? .Times(cardinality) ? .InSequence(sequences) * .After(expectations) * .WillOnce(action) * .WillRepeatedly(action) ? .RetiresOnSaturation(); ?
If Times()
is omitted, the cardinality is assumed to be:
不顯示調用times時 各種情況下他的默認值
Times(1)
when there is neitherWillOnce()
norWillRepeatedly()
;- 當沒有willOnce()或willRepeated()時的
Times
(1); Times(n)
when there aren WillOnce()
s but noWillRepeatedly()
, wheren
>= 1; or- 當存在n willOnce()s但沒有willRepeated()時的次數(n),其中n大於等於1;
Times(AtLeast(n))
when there aren WillOnce()
s and aWillRepeatedly()
, wheren
>= 0.- 不帶expect_call()的方法可以任意多次調用,每次都將執行默認操作。
A method with no EXPECT_CALL()
is free to be invoked any number of times, and the default action will be taken each time.
Matchers
A matcher matches a single argument. You can use it inside ON_CALL()
or EXPECT_CALL()
, or use it to validate a value directly:
匹配器 匹配單個參數,可以在ON_CALL EXPECT_CALL 或者直接驗證某個值。
Matcher | Description |
---|---|
EXPECT_THAT(value, matcher) |
Asserts that value matches matcher . |
ASSERT_THAT(value, matcher) |
The same as EXPECT_THAT(value, matcher) , except that it generates a fatal failure. |
Built-in matchers (where argument
is the function argument) are divided into several categories:
內置匹配器(其中參數是函數參數)分爲幾個類別:
Wildcard 通配符
Matcher | Description |
---|---|
_ |
argument can be any value of the correct type. |
A<type>() or An<type>() |
argument can be any value of type type .匹配類型就行 |
Generic Comparison通用比較
Matcher | Description |
---|---|
Eq(value) or value |
argument == value |
Ge(value) |
argument >= value |
Gt(value) |
argument > value |
Le(value) |
argument <= value |
Lt(value) |
argument < value |
Ne(value) |
argument != value |
IsNull() |
argument is a NULL pointer (raw or smart). |
NotNull() |
argument is a non-null pointer (raw or smart). |
Optional(m) |
argument is optional<> that contains a value matching m . |
VariantWith<T>(m) |
argument is variant<> that holds the alternative of type T with a value matching m . |
Ref(variable) |
argument is a reference to variable . |
TypedEq<type>(value) |
argument has type type and is equal to value . You may need to use this instead of Eq(value) when the mock function is overloaded. |
Except Ref()
, these matchers make a copy of value
in case it's modified or destructed later. If the compiler complains that value
doesn't have a public copy constructor, try wrap it in ByRef()
, e.g. Eq(ByRef(non_copyable_value))
. If you do that, make sure non_copyable_value
is not changed afterwards, or the meaning of your matcher will be changed.
Floating-Point Matchers 浮點數匹配器
Matcher | Description |
---|---|
DoubleEq(a_double) |
argument is a double value approximately equal to a_double , treating two NaNs as unequal. |
FloatEq(a_float) |
argument is a float value approximately equal to a_float , treating two NaNs as unequal. |
NanSensitiveDoubleEq(a_double) |
argument is a double value approximately equal to a_double , treating two NaNs as equal. |
NanSensitiveFloatEq(a_float) |
argument is a float value approximately equal to a_float , treating two NaNs as equal. |
String Matchers 字符串匹配器
Matcher | Description |
---|---|
ContainsRegex(string) |
argument matches the given regular expression. |
EndsWith(suffix) |
argument ends with string suffix . |
HasSubstr(string) |
argument contains string as a sub-string. |
MatchesRegex(string) |
argument matches the given regular expression with the match starting at the first character and ending at the last character. |
StartsWith(prefix) |
argument starts with string prefix . |
StrCaseEq(string) |
argument is equal to string , ignoring case. |
StrCaseNe(string) |
argument is not equal to string , ignoring case. |
StrEq(string) |
argument is equal to string . |
StrNe(string) |
argument is not equal to string . |
Container Matchers 標準庫容器匹配器
Matcher | Description |
---|---|
ContainerEq(container) |
The same as Eq(container) except that the failure message also includes which elements are in one container but not the other. |
Contains(e) |
argument contains an element that matches e , which can be either a value or a matcher. |
Each(e) |
argument is a container where every element matches e , which can be either a value or a matcher. |
ElementsAre(e0, e1, ..., en) |
argument has n + 1 elements, where the i-th element matches ei , which can be a value or a matcher. 0 to 10 arguments are allowed. |
ElementsAreArray({ e0, e1, ..., en }) , ElementsAreArray(array) , or ElementsAreArray(array, count) |
The same as ElementsAre() except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
IsEmpty() |
argument is an empty container (container.empty() ). |
Pointwise(m, container) |
argument contains the same number of elements as in container , and for all i, (the i-th element in argument , the i-th element in container ) match m , which is a matcher on 2-tuples. E.g. Pointwise(Le(), upper_bounds) verifies that each element in argument doesn't exceed the corresponding element in upper_bounds . See more detail below. |
SizeIs(m) |
argument is a container whose size matches m . E.g. SizeIs(2) or SizeIs(Lt(2)) . |
UnorderedElementsAre(e0, e1, ..., en) |
argument has n + 1 elements, and under some permutation each element matches an ei (for a different i ), which can be a value or a matcher. 0 to 10 arguments are allowed. |
UnorderedElementsAreArray({ e0, e1, ..., en }) , UnorderedElementsAreArray(array) , or UnorderedElementsAreArray(array, count) |
The same as UnorderedElementsAre() except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
WhenSorted(m) |
When argument is sorted using the < operator, it matches container matcher m . E.g. WhenSorted(ElementsAre(1, 2, 3)) verifies that argument contains elements 1 , 2 , and 3 , ignoring order. |
WhenSortedBy(comparator, m) |
The same as WhenSorted(m) , except that the given comparator instead of < is used to sort argument . E.g. WhenSortedBy(std::greater<int>(), ElementsAre(3, 2, 1)) . |
Member Matchers 成員匹配器
Matcher | Description |
---|---|
Field(&class::field, m) |
argument.field (or argument->field when argument is a plain pointer) matches matcher m , where argument is an object of type class. |
Key(e) |
argument.first matches e , which can be either a value or a matcher. E.g. Contains(Key(Le(5))) can verify that a map contains a key <= 5 . |
Pair(m1, m2) |
argument is an std::pair whose first field matches m1 and second field matches m2 . |
Property(&class::property, m) |
argument.property() (or argument->property() when argument is a plain pointer) matches matcher m , where argument is an object of type class. |
Matching the Result of a Function or Functor
Matcher | Description |
---|---|
ResultOf(f, m) |
f(argument) matches matcher m , where f is a function or functor. |
Pointer Matchers
Matcher | Description |
---|---|
Pointee(m) |
argument (either a smart pointer or a raw pointer) points to a value that matches matcher m . |
WhenDynamicCastTo<T>(m) |
when argument is passed through dynamic_cast<T>() , it matches matcher m . |
Multiargument Matchers
Composite Matchers
Adapters for Matchers
Matchers as Predicates
Defining Matchers 有點像lambda 函數
Matcher | Description |
---|---|
MATCHER(IsEven, "") { return (arg % 2) == 0; } |
Defines a matcher IsEven() to match an even number. |
MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; } |
Defines a macher IsDivisibleBy(n) to match a number divisible by n . |
MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; } |
Defines a matcher IsBetween(a, b) to match a value in the range [a , b ]. |
Matchers as Test Assertions
Matcher | Description |
---|---|
ASSERT_THAT(expression, m) |
Generates a fatal failure if the value of expression doesn't match matcher m . |
EXPECT_THAT(expression, m) |
Generates a non-fatal failure if the value of expression doesn't match matcher m . |
Actions
Actions specify what a mock function should do when invoked.
操作指定模擬函數在被調用時應該做什麼。
Returning a Value 驗證返回值
Matcher | Description |
---|---|
Return() |
Return from a void mock function. |
Return(value) |
Return value . If the type of value is different to the mock function's return type, value is converted to the latter type at the time the expectation is set, not when the action is executed. |
ReturnArg<N>() |
Return the N -th (0-based) argument. |
ReturnNew<T>(a1, ..., ak) |
Return new T(a1, ..., ak) ; a different object is created each time. |
ReturnNull() |
Return a null pointer. |
ReturnPointee(ptr) |
Return the value pointed to by ptr . |
ReturnRef(variable) |
Return a reference to variable . |
ReturnRefOfCopy(value) |
Return a reference to a copy of value ; the copy lives as long as the action. |
Side Effects
Matcher | Description |
---|---|
Assign(&variable, value) |
Assign value to variable. |
DeleteArg<N>() |
Delete the N -th (0-based) argument, which must be a pointer. |
SaveArg<N>(pointer) |
Save the N -th (0-based) argument to *pointer . |
SaveArgPointee<N>(pointer) |
Save the value pointed to by the N -th (0-based) argument to *pointer . |
SetArgReferee<N>(value) |
Assign value to the variable referenced by the N -th (0-based) argument. |
SetArgPointee<N>(value) |
Assign value to the variable pointed by the N -th (0-based) argument. |
SetArgumentPointee<N>(value) |
Same as SetArgPointee<N>(value) . Deprecated. Will be removed in v1.7.0. |
SetArrayArgument<N>(first, last) |
Copies the elements in source range [first , last ) to the array pointed to by the N -th (0-based) argument, which can be either a pointer or an iterator. The action does not take ownership of the elements in the source range. |
SetErrnoAndReturn(error, value) |
Set errno to error and return value . |
Throw(exception) |
Throws the given exception, which can be any copyable value. Available since v1.1.0. |
Using a Function or a Functor as an Action
Matcher | Description |
---|---|
Invoke(f) |
Invoke f with the arguments passed to the mock function, where f can be a global/static function or a functor. |
Invoke(object_pointer, &class::method) |
Invoke the {method on the object with the arguments passed to the mock function. |
InvokeWithoutArgs(f) |
Invoke f , which can be a global/static function or a functor. f must take no arguments. |
InvokeWithoutArgs(object_pointer, &class::method) |
Invoke the method on the object, which takes no arguments. |
InvokeArgument<N>(arg1, arg2, ..., argk) |
Invoke the mock function's N -th (0-based) argument, which must be a function or a functor, with the k arguments. |
Default Action
Composite Actions
Matcher | Description |
---|---|
DoAll(a1, a2, ..., an) |
Do all actions a1 to an and return the result of an in each invocation. The first n - 1 sub-actions must return void. |
IgnoreResult(a) |
Perform action a and ignore its result. a must not return void. |
WithArg<N>(a) |
Pass the N -th (0-based) argument of the mock function to action a and perform it. |
WithArgs<N1, N2, ..., Nk>(a) |
Pass the selected (0-based) arguments of the mock function to action a and perform it. |
WithoutArgs(a) |
Perform action a without any arguments. |
Defining Actions
定義方法
Matcher | Description |
---|---|
ACTION(Sum) { return arg0 + arg1; } |
Defines an action Sum() to return the sum of the mock function's argument #0 and #1. |
ACTION_P(Plus, n) { return arg0 + n; } |
Defines an action Plus(n) to return the sum of the mock function's argument #0 and n . |
ACTION_Pk(Foo, p1, ..., pk) { statements; } |
Defines a parameterized action Foo(p1, ..., pk) to execute the given statements . |
The ACTION*
macros cannot be used inside a function or class.
Cardinalities
These are used in Times()
to specify how many times a mock function will be called:
調用次數
Matcher | Description |
---|---|
AnyNumber() |
The function can be called any number of times. |
AtLeast(n) |
The call is expected at least n times. |
AtMost(n) |
The call is expected at most n times. |
Between(m, n) |
The call is expected between m and n (inclusive) times. |
Exactly(n) or n |
The call is expected exactly n times. In particular, the call should never happen when n is 0. |
Expectation Order 期望的執行順序
By default, the expectations can be matched in any order. If some or all expectations must be matched in a given order, there are two ways to specify it. They can be used either independently or together.
默認情況下,期望值可以按照任意順序匹配。如果有些期望值需要按照給定的順序匹配,有兩種方式來定義,這兩種方式可以一起使用也可以單個使用。The After Clause & Sequences
The After Clause Sequences
using ::testing::Expectation;
...
Expectation init_x = EXPECT_CALL(foo, InitX());
Expectation init_y = EXPECT_CALL(foo, InitY());
EXPECT_CALL(foo, Bar())
.After(init_x, init_y);
says that Bar()
can be called only after both InitX()
and InitY()
have been called.
例子的after意思是需要在InitX()
and InitY()
調用之後 Bar()才能被調用;
If you don't know how many pre-requisites an expectation has when you write it, you can use an ExpectationSet
to collect them:
using ::testing::ExpectationSet;
...
ExpectationSet all_inits;
for (int i = 0; i < element_count; i++) {
all_inits += EXPECT_CALL(foo, InitElement(i));
}
EXPECT_CALL(foo, Bar())
.After(all_inits);
says that Bar()
can be called only after all elements have been initialized (but we don't care about which elements get initialized before the others).
Modifying an ExpectationSet
after using it in an .After()
doesn't affect the meaning of the .After()
.
Sequences
When you have a long chain of sequential expectations, it's easier to specify the order using sequences, which don't require you to given each expectation in the chain a different name. All expected calls in the same sequence must occur in the order they are specified.
當您有一個長的序列期望鏈時,使用序列來指定順序會更容易,這不需要您爲鏈中的每個期望賦予不同的名稱。相同順序的所有預期調用都必須按指定的順序進行。
using ::testing::Sequence;
Sequence s1, s2;
...
EXPECT_CALL(foo, Reset())
.InSequence(s1, s2)
.WillOnce(Return(true));
EXPECT_CALL(foo, GetSize())
.InSequence(s1)
.WillOnce(Return(1));
EXPECT_CALL(foo, Describe(A<const char*>()))
.InSequence(s2)
.WillOnce(Return("dummy"));
says that Reset()
must be called before both GetSize()
and Describe()
, and the latter two can occur in any order.
表示必須在getSize()和describe()之前調用reset(),後兩個函數可以以任意順序發生。
using ::testing::InSequence;
{
InSequence dummy;
EXPECT_CALL(...)...;
EXPECT_CALL(...)...;
...
EXPECT_CALL(...)...;
}
using ::testing::InSequence;所有按照順序執行
Verifying and Resetting a Mock
驗證和重置
Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
當模擬對象被析構時,Google Mock將驗證對它的期望,或者您可以更早地進行驗證:
using ::testing::Mock;
...
// Verifies and removes the expectations on mock_obj;
// returns true if successful.
Mock::VerifyAndClearExpectations(&mock_obj);
...
// Verifies and removes the expectations on mock_obj;
// also removes the default actions set by ON_CALL();
// returns true if successful.
Mock::VerifyAndClear(&mock_obj);
You can also tell Google Mock that a mock object can be leaked and doesn't need to be verified:
不檢查內存泄漏
Mock::AllowLeak(&mock_obj);
Mock Classes
Google Mock defines a convenient mock class template
class MockFunction<R(A1, ..., An)> {
public:
MOCK_METHODn(Call, R(A1, ..., An));
};
See this recipe for one application of it.
Flags
Flag | Description |
---|---|
--gmock_catch_leaked_mocks=0 |
Don't report leaked mock objects as failures. |
--gmock_verbose=LEVEL |
Sets the default verbosity level (info , warning , or error ) of Google Mock messages. |