| 1 |
# Mocking Reference |
| 2 |
|
| 3 |
This page lists the facilities provided by GoogleTest for creating and working |
| 4 |
with mock objects. To use them, include the header |
| 5 |
`gmock/gmock.h`. |
| 6 |
|
| 7 |
## Macros {#macros} |
| 8 |
|
| 9 |
GoogleTest defines the following macros for working with mocks. |
| 10 |
|
| 11 |
### MOCK_METHOD {#MOCK_METHOD} |
| 12 |
|
| 13 |
`MOCK_METHOD(`*`return_type`*`,`*`method_name`*`, (`*`args...`*`));` \ |
| 14 |
`MOCK_METHOD(`*`return_type`*`,`*`method_name`*`, (`*`args...`*`), |
| 15 |
(`*`specs...`*`));` |
| 16 |
|
| 17 |
Defines a mock method *`method_name`* with arguments `(`*`args...`*`)` and |
| 18 |
return type *`return_type`* within a mock class. |
| 19 |
|
| 20 |
The parameters of `MOCK_METHOD` mirror the method declaration. The optional |
| 21 |
fourth parameter *`specs...`* is a comma-separated list of qualifiers. The |
| 22 |
following qualifiers are accepted: |
| 23 |
|
| 24 |
| Qualifier | Meaning | |
| 25 |
| -------------------------- | -------------------------------------------- | |
| 26 |
| `const` | Makes the mocked method a `const` method. Required if overriding a `const` method. | |
| 27 |
| `override` | Marks the method with `override`. Recommended if overriding a `virtual` method. | |
| 28 |
| `noexcept` | Marks the method with `noexcept`. Required if overriding a `noexcept` method. | |
| 29 |
| `Calltype(`*`calltype`*`)` | Sets the call type for the method, for example `Calltype(STDMETHODCALLTYPE)`. Useful on Windows. | |
| 30 |
| `ref(`*`qualifier`*`)` | Marks the method with the given reference qualifier, for example `ref(&)` or `ref(&&)`. Required if overriding a method that has a reference qualifier. | |
| 31 |
|
| 32 |
Note that commas in arguments prevent `MOCK_METHOD` from parsing the arguments |
| 33 |
correctly if they are not appropriately surrounded by parentheses. See the |
| 34 |
following example: |
| 35 |
|
| 36 |
```cpp |
| 37 |
class MyMock { |
| 38 |
public: |
| 39 |
// The following 2 lines will not compile due to commas in the arguments: |
| 40 |
MOCK_METHOD(std::pair<bool, int>, GetPair, ()); // Error! |
| 41 |
MOCK_METHOD(bool, CheckMap, (std::map<int, double>, bool)); // Error! |
| 42 |
|
| 43 |
// One solution - wrap arguments that contain commas in parentheses: |
| 44 |
MOCK_METHOD((std::pair<bool, int>), GetPair, ()); |
| 45 |
MOCK_METHOD(bool, CheckMap, ((std::map<int, double>), bool)); |
| 46 |
|
| 47 |
// Another solution - use type aliases: |
| 48 |
using BoolAndInt = std::pair<bool, int>; |
| 49 |
MOCK_METHOD(BoolAndInt, GetPair, ()); |
| 50 |
using MapIntDouble = std::map<int, double>; |
| 51 |
MOCK_METHOD(bool, CheckMap, (MapIntDouble, bool)); |
| 52 |
}; |
| 53 |
``` |
| 54 |
|
| 55 |
`MOCK_METHOD` must be used in the `public:` section of a mock class definition, |
| 56 |
regardless of whether the method being mocked is `public`, `protected`, or |
| 57 |
`private` in the base class. |
| 58 |
|
| 59 |
### EXPECT_CALL {#EXPECT_CALL} |
| 60 |
|
| 61 |
`EXPECT_CALL(`*`mock_object`*`,`*`method_name`*`(`*`matchers...`*`))` |
| 62 |
|
| 63 |
Creates an [expectation](../gmock_for_dummies.md#setting-expectations) that the |
| 64 |
method *`method_name`* of the object *`mock_object`* is called with arguments |
| 65 |
that match the given matchers *`matchers...`*. `EXPECT_CALL` must precede any |
| 66 |
code that exercises the mock object. |
| 67 |
|
| 68 |
The parameter *`matchers...`* is a comma-separated list of |
| 69 |
[matchers](../gmock_for_dummies.md#matchers-what-arguments-do-we-expect) that |
| 70 |
correspond to each argument of the method *`method_name`*. The expectation will |
| 71 |
apply only to calls of *`method_name`* whose arguments match all of the |
| 72 |
matchers. If `(`*`matchers...`*`)` is omitted, the expectation behaves as if |
| 73 |
each argument's matcher were a [wildcard matcher (`_`)](matchers.md#wildcard). |
| 74 |
See the [Matchers Reference](matchers.md) for a list of all built-in matchers. |
| 75 |
|
| 76 |
The following chainable clauses can be used to modify the expectation, and they |
| 77 |
must be used in the following order: |
| 78 |
|
| 79 |
```cpp |
| 80 |
EXPECT_CALL(mock_object, method_name(matchers...)) |
| 81 |
.With(multi_argument_matcher) // Can be used at most once |
| 82 |
.Times(cardinality) // Can be used at most once |
| 83 |
.InSequence(sequences...) // Can be used any number of times |
| 84 |
.After(expectations...) // Can be used any number of times |
| 85 |
.WillOnce(action) // Can be used any number of times |
| 86 |
.WillRepeatedly(action) // Can be used at most once |
| 87 |
.RetiresOnSaturation(); // Can be used at most once |
| 88 |
``` |
| 89 |
|
| 90 |
See details for each modifier clause below. |
| 91 |
|
| 92 |
#### With {#EXPECT_CALL.With} |
| 93 |
|
| 94 |
`.With(`*`multi_argument_matcher`*`)` |
| 95 |
|
| 96 |
Restricts the expectation to apply only to mock function calls whose arguments |
| 97 |
as a whole match the multi-argument matcher *`multi_argument_matcher`*. |
| 98 |
|
| 99 |
GoogleTest passes all of the arguments as one tuple into the matcher. The |
| 100 |
parameter *`multi_argument_matcher`* must thus be a matcher of type |
| 101 |
`Matcher<std::tuple<A1, ..., An>>`, where `A1, ..., An` are the types of the |
| 102 |
function arguments. |
| 103 |
|
| 104 |
For example, the following code sets the expectation that |
| 105 |
`my_mock.SetPosition()` is called with any two arguments, the first argument |
| 106 |
being less than the second: |
| 107 |
|
| 108 |
```cpp |
| 109 |
using ::testing::_; |
| 110 |
using ::testing::Lt; |
| 111 |
... |
| 112 |
EXPECT_CALL(my_mock, SetPosition(_, _)) |
| 113 |
.With(Lt()); |
| 114 |
``` |
| 115 |
|
| 116 |
GoogleTest provides some built-in matchers for 2-tuples, including the `Lt()` |
| 117 |
matcher above. See [Multi-argument Matchers](matchers.md#MultiArgMatchers). |
| 118 |
|
| 119 |
The `With` clause can be used at most once on an expectation and must be the |
| 120 |
first clause. |
| 121 |
|
| 122 |
#### Times {#EXPECT_CALL.Times} |
| 123 |
|
| 124 |
`.Times(`*`cardinality`*`)` |
| 125 |
|
| 126 |
Specifies how many times the mock function call is expected. |
| 127 |
|
| 128 |
The parameter *`cardinality`* represents the number of expected calls and can be |
| 129 |
one of the following, all defined in the `::testing` namespace: |
| 130 |
|
| 131 |
| Cardinality | Meaning | |
| 132 |
| ------------------- | --------------------------------------------------- | |
| 133 |
| `AnyNumber()` | The function can be called any number of times. | |
| 134 |
| `AtLeast(n)` | The function call is expected at least *n* times. | |
| 135 |
| `AtMost(n)` | The function call is expected at most *n* times. | |
| 136 |
| `Between(m, n)` | The function call is expected between *m* and *n* times, inclusive. | |
| 137 |
| `Exactly(n)` or `n` | The function call is expected exactly *n* times. If *n* is 0, the call should never happen. | |
| 138 |
|
| 139 |
If the `Times` clause is omitted, GoogleTest infers the cardinality as follows: |
| 140 |
|
| 141 |
* If neither [`WillOnce`](#EXPECT_CALL.WillOnce) nor |
| 142 |
[`WillRepeatedly`](#EXPECT_CALL.WillRepeatedly) are specified, the inferred |
| 143 |
cardinality is `Times(1)`. |
| 144 |
* If there are *n* `WillOnce` clauses and no `WillRepeatedly` clause, where |
| 145 |
*n* >= 1, the inferred cardinality is `Times(n)`. |
| 146 |
* If there are *n* `WillOnce` clauses and one `WillRepeatedly` clause, where |
| 147 |
*n* >= 0, the inferred cardinality is `Times(AtLeast(n))`. |
| 148 |
|
| 149 |
The `Times` clause can be used at most once on an expectation. |
| 150 |
|
| 151 |
#### InSequence {#EXPECT_CALL.InSequence} |
| 152 |
|
| 153 |
`.InSequence(`*`sequences...`*`)` |
| 154 |
|
| 155 |
Specifies that the mock function call is expected in a certain sequence. |
| 156 |
|
| 157 |
The parameter *`sequences...`* is any number of [`Sequence`](#Sequence) objects. |
| 158 |
Expected calls assigned to the same sequence are expected to occur in the order |
| 159 |
the expectations are declared. |
| 160 |
|
| 161 |
For example, the following code sets the expectation that the `Reset()` method |
| 162 |
of `my_mock` is called before both `GetSize()` and `Describe()`, and `GetSize()` |
| 163 |
and `Describe()` can occur in any order relative to each other: |
| 164 |
|
| 165 |
```cpp |
| 166 |
using ::testing::Sequence; |
| 167 |
Sequence s1, s2; |
| 168 |
... |
| 169 |
EXPECT_CALL(my_mock, Reset()) |
| 170 |
.InSequence(s1, s2); |
| 171 |
EXPECT_CALL(my_mock, GetSize()) |
| 172 |
.InSequence(s1); |
| 173 |
EXPECT_CALL(my_mock, Describe()) |
| 174 |
.InSequence(s2); |
| 175 |
``` |
| 176 |
|
| 177 |
The `InSequence` clause can be used any number of times on an expectation. |
| 178 |
|
| 179 |
See also the [`InSequence` class](#InSequence). |
| 180 |
|
| 181 |
#### After {#EXPECT_CALL.After} |
| 182 |
|
| 183 |
`.After(`*`expectations...`*`)` |
| 184 |
|
| 185 |
Specifies that the mock function call is expected to occur after one or more |
| 186 |
other calls. |
| 187 |
|
| 188 |
The parameter *`expectations...`* can be up to five |
| 189 |
[`Expectation`](#Expectation) or [`ExpectationSet`](#ExpectationSet) objects. |
| 190 |
The mock function call is expected to occur after all of the given expectations. |
| 191 |
|
| 192 |
For example, the following code sets the expectation that the `Describe()` |
| 193 |
method of `my_mock` is called only after both `InitX()` and `InitY()` have been |
| 194 |
called. |
| 195 |
|
| 196 |
```cpp |
| 197 |
using ::testing::Expectation; |
| 198 |
... |
| 199 |
Expectation init_x = EXPECT_CALL(my_mock, InitX()); |
| 200 |
Expectation init_y = EXPECT_CALL(my_mock, InitY()); |
| 201 |
EXPECT_CALL(my_mock, Describe()) |
| 202 |
.After(init_x, init_y); |
| 203 |
``` |
| 204 |
|
| 205 |
The `ExpectationSet` object is helpful when the number of prerequisites for an |
| 206 |
expectation is large or variable, for example: |
| 207 |
|
| 208 |
```cpp |
| 209 |
using ::testing::ExpectationSet; |
| 210 |
... |
| 211 |
ExpectationSet all_inits; |
| 212 |
// Collect all expectations of InitElement() calls |
| 213 |
for (int i = 0; i < element_count; i++) { |
| 214 |
all_inits += EXPECT_CALL(my_mock, InitElement(i)); |
| 215 |
} |
| 216 |
EXPECT_CALL(my_mock, Describe()) |
| 217 |
.After(all_inits); // Expect Describe() call after all InitElement() calls |
| 218 |
``` |
| 219 |
|
| 220 |
The `After` clause can be used any number of times on an expectation. |
| 221 |
|
| 222 |
#### WillOnce {#EXPECT_CALL.WillOnce} |
| 223 |
|
| 224 |
`.WillOnce(`*`action`*`)` |
| 225 |
|
| 226 |
Specifies the mock function's actual behavior when invoked, for a single |
| 227 |
matching function call. |
| 228 |
|
| 229 |
The parameter *`action`* represents the |
| 230 |
[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function |
| 231 |
call will perform. See the [Actions Reference](actions.md) for a list of |
| 232 |
built-in actions. |
| 233 |
|
| 234 |
The use of `WillOnce` implicitly sets a cardinality on the expectation when |
| 235 |
`Times` is not specified. See [`Times`](#EXPECT_CALL.Times). |
| 236 |
|
| 237 |
Each matching function call will perform the next action in the order declared. |
| 238 |
For example, the following code specifies that `my_mock.GetNumber()` is expected |
| 239 |
to be called exactly 3 times and will return `1`, `2`, and `3` respectively on |
| 240 |
the first, second, and third calls: |
| 241 |
|
| 242 |
```cpp |
| 243 |
using ::testing::Return; |
| 244 |
... |
| 245 |
EXPECT_CALL(my_mock, GetNumber()) |
| 246 |
.WillOnce(Return(1)) |
| 247 |
.WillOnce(Return(2)) |
| 248 |
.WillOnce(Return(3)); |
| 249 |
``` |
| 250 |
|
| 251 |
The `WillOnce` clause can be used any number of times on an expectation. |
| 252 |
|
| 253 |
#### WillRepeatedly {#EXPECT_CALL.WillRepeatedly} |
| 254 |
|
| 255 |
`.WillRepeatedly(`*`action`*`)` |
| 256 |
|
| 257 |
Specifies the mock function's actual behavior when invoked, for all subsequent |
| 258 |
matching function calls. Takes effect after the actions specified in the |
| 259 |
[`WillOnce`](#EXPECT_CALL.WillOnce) clauses, if any, have been performed. |
| 260 |
|
| 261 |
The parameter *`action`* represents the |
| 262 |
[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function |
| 263 |
call will perform. See the [Actions Reference](actions.md) for a list of |
| 264 |
built-in actions. |
| 265 |
|
| 266 |
The use of `WillRepeatedly` implicitly sets a cardinality on the expectation |
| 267 |
when `Times` is not specified. See [`Times`](#EXPECT_CALL.Times). |
| 268 |
|
| 269 |
If any `WillOnce` clauses have been specified, matching function calls will |
| 270 |
perform those actions before the action specified by `WillRepeatedly`. See the |
| 271 |
following example: |
| 272 |
|
| 273 |
```cpp |
| 274 |
using ::testing::Return; |
| 275 |
... |
| 276 |
EXPECT_CALL(my_mock, GetName()) |
| 277 |
.WillRepeatedly(Return("John Doe")); // Return "John Doe" on all calls |
| 278 |
|
| 279 |
EXPECT_CALL(my_mock, GetNumber()) |
| 280 |
.WillOnce(Return(42)) // Return 42 on the first call |
| 281 |
.WillRepeatedly(Return(7)); // Return 7 on all subsequent calls |
| 282 |
``` |
| 283 |
|
| 284 |
The `WillRepeatedly` clause can be used at most once on an expectation. |
| 285 |
|
| 286 |
#### RetiresOnSaturation {#EXPECT_CALL.RetiresOnSaturation} |
| 287 |
|
| 288 |
`.RetiresOnSaturation()` |
| 289 |
|
| 290 |
Indicates that the expectation will no longer be active after the expected |
| 291 |
number of matching function calls has been reached. |
| 292 |
|
| 293 |
The `RetiresOnSaturation` clause is only meaningful for expectations with an |
| 294 |
upper-bounded cardinality. The expectation will *retire* (no longer match any |
| 295 |
function calls) after it has been *saturated* (the upper bound has been |
| 296 |
reached). See the following example: |
| 297 |
|
| 298 |
```cpp |
| 299 |
using ::testing::_; |
| 300 |
using ::testing::AnyNumber; |
| 301 |
... |
| 302 |
EXPECT_CALL(my_mock, SetNumber(_)) // Expectation 1 |
| 303 |
.Times(AnyNumber()); |
| 304 |
EXPECT_CALL(my_mock, SetNumber(7)) // Expectation 2 |
| 305 |
.Times(2) |
| 306 |
.RetiresOnSaturation(); |
| 307 |
``` |
| 308 |
|
| 309 |
In the above example, the first two calls to `my_mock.SetNumber(7)` match |
| 310 |
expectation 2, which then becomes inactive and no longer matches any calls. A |
| 311 |
third call to `my_mock.SetNumber(7)` would then match expectation 1. Without |
| 312 |
`RetiresOnSaturation()` on expectation 2, a third call to `my_mock.SetNumber(7)` |
| 313 |
would match expectation 2 again, producing a failure since the limit of 2 calls |
| 314 |
was exceeded. |
| 315 |
|
| 316 |
The `RetiresOnSaturation` clause can be used at most once on an expectation and |
| 317 |
must be the last clause. |
| 318 |
|
| 319 |
### ON_CALL {#ON_CALL} |
| 320 |
|
| 321 |
`ON_CALL(`*`mock_object`*`,`*`method_name`*`(`*`matchers...`*`))` |
| 322 |
|
| 323 |
Defines what happens when the method *`method_name`* of the object |
| 324 |
*`mock_object`* is called with arguments that match the given matchers |
| 325 |
*`matchers...`*. Requires a modifier clause to specify the method's behavior. |
| 326 |
*Does not* set any expectations that the method will be called. |
| 327 |
|
| 328 |
The parameter *`matchers...`* is a comma-separated list of |
| 329 |
[matchers](../gmock_for_dummies.md#matchers-what-arguments-do-we-expect) that |
| 330 |
correspond to each argument of the method *`method_name`*. The `ON_CALL` |
| 331 |
specification will apply only to calls of *`method_name`* whose arguments match |
| 332 |
all of the matchers. If `(`*`matchers...`*`)` is omitted, the behavior is as if |
| 333 |
each argument's matcher were a [wildcard matcher (`_`)](matchers.md#wildcard). |
| 334 |
See the [Matchers Reference](matchers.md) for a list of all built-in matchers. |
| 335 |
|
| 336 |
The following chainable clauses can be used to set the method's behavior, and |
| 337 |
they must be used in the following order: |
| 338 |
|
| 339 |
```cpp |
| 340 |
ON_CALL(mock_object, method_name(matchers...)) |
| 341 |
.With(multi_argument_matcher) // Can be used at most once |
| 342 |
.WillByDefault(action); // Required |
| 343 |
``` |
| 344 |
|
| 345 |
See details for each modifier clause below. |
| 346 |
|
| 347 |
#### With {#ON_CALL.With} |
| 348 |
|
| 349 |
`.With(`*`multi_argument_matcher`*`)` |
| 350 |
|
| 351 |
Restricts the specification to only mock function calls whose arguments as a |
| 352 |
whole match the multi-argument matcher *`multi_argument_matcher`*. |
| 353 |
|
| 354 |
GoogleTest passes all of the arguments as one tuple into the matcher. The |
| 355 |
parameter *`multi_argument_matcher`* must thus be a matcher of type |
| 356 |
`Matcher<std::tuple<A1, ..., An>>`, where `A1, ..., An` are the types of the |
| 357 |
function arguments. |
| 358 |
|
| 359 |
For example, the following code sets the default behavior when |
| 360 |
`my_mock.SetPosition()` is called with any two arguments, the first argument |
| 361 |
being less than the second: |
| 362 |
|
| 363 |
```cpp |
| 364 |
using ::testing::_; |
| 365 |
using ::testing::Lt; |
| 366 |
using ::testing::Return; |
| 367 |
... |
| 368 |
ON_CALL(my_mock, SetPosition(_, _)) |
| 369 |
.With(Lt()) |
| 370 |
.WillByDefault(Return(true)); |
| 371 |
``` |
| 372 |
|
| 373 |
GoogleTest provides some built-in matchers for 2-tuples, including the `Lt()` |
| 374 |
matcher above. See [Multi-argument Matchers](matchers.md#MultiArgMatchers). |
| 375 |
|
| 376 |
The `With` clause can be used at most once with each `ON_CALL` statement. |
| 377 |
|
| 378 |
#### WillByDefault {#ON_CALL.WillByDefault} |
| 379 |
|
| 380 |
`.WillByDefault(`*`action`*`)` |
| 381 |
|
| 382 |
Specifies the default behavior of a matching mock function call. |
| 383 |
|
| 384 |
The parameter *`action`* represents the |
| 385 |
[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function |
| 386 |
call will perform. See the [Actions Reference](actions.md) for a list of |
| 387 |
built-in actions. |
| 388 |
|
| 389 |
For example, the following code specifies that by default, a call to |
| 390 |
`my_mock.Greet()` will return `"hello"`: |
| 391 |
|
| 392 |
```cpp |
| 393 |
using ::testing::Return; |
| 394 |
... |
| 395 |
ON_CALL(my_mock, Greet()) |
| 396 |
.WillByDefault(Return("hello")); |
| 397 |
``` |
| 398 |
|
| 399 |
The action specified by `WillByDefault` is superseded by the actions specified |
| 400 |
on a matching `EXPECT_CALL` statement, if any. See the |
| 401 |
[`WillOnce`](#EXPECT_CALL.WillOnce) and |
| 402 |
[`WillRepeatedly`](#EXPECT_CALL.WillRepeatedly) clauses of `EXPECT_CALL`. |
| 403 |
|
| 404 |
The `WillByDefault` clause must be used exactly once with each `ON_CALL` |
| 405 |
statement. |
| 406 |
|
| 407 |
## Classes {#classes} |
| 408 |
|
| 409 |
GoogleTest defines the following classes for working with mocks. |
| 410 |
|
| 411 |
### DefaultValue {#DefaultValue} |
| 412 |
|
| 413 |
`::testing::DefaultValue<T>` |
| 414 |
|
| 415 |
Allows a user to specify the default value for a type `T` that is both copyable |
| 416 |
and publicly destructible (i.e. anything that can be used as a function return |
| 417 |
type). For mock functions with a return type of `T`, this default value is |
| 418 |
returned from function calls that do not specify an action. |
| 419 |
|
| 420 |
Provides the static methods `Set()`, `SetFactory()`, and `Clear()` to manage the |
| 421 |
default value: |
| 422 |
|
| 423 |
```cpp |
| 424 |
// Sets the default value to be returned. T must be copy constructible. |
| 425 |
DefaultValue<T>::Set(value); |
| 426 |
|
| 427 |
// Sets a factory. Will be invoked on demand. T must be move constructible. |
| 428 |
T MakeT(); |
| 429 |
DefaultValue<T>::SetFactory(&MakeT); |
| 430 |
|
| 431 |
// Unsets the default value. |
| 432 |
DefaultValue<T>::Clear(); |
| 433 |
``` |
| 434 |
|
| 435 |
### NiceMock {#NiceMock} |
| 436 |
|
| 437 |
`::testing::NiceMock<T>` |
| 438 |
|
| 439 |
Represents a mock object that suppresses warnings on |
| 440 |
[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The |
| 441 |
template parameter `T` is any mock class, except for another `NiceMock`, |
| 442 |
`NaggyMock`, or `StrictMock`. |
| 443 |
|
| 444 |
Usage of `NiceMock<T>` is analogous to usage of `T`. `NiceMock<T>` is a subclass |
| 445 |
of `T`, so it can be used wherever an object of type `T` is accepted. In |
| 446 |
addition, `NiceMock<T>` can be constructed with any arguments that a constructor |
| 447 |
of `T` accepts. |
| 448 |
|
| 449 |
For example, the following code suppresses warnings on the mock `my_mock` of |
| 450 |
type `MockClass` if a method other than `DoSomething()` is called: |
| 451 |
|
| 452 |
```cpp |
| 453 |
using ::testing::NiceMock; |
| 454 |
... |
| 455 |
NiceMock<MockClass> my_mock("some", "args"); |
| 456 |
EXPECT_CALL(my_mock, DoSomething()); |
| 457 |
... code that uses my_mock ... |
| 458 |
``` |
| 459 |
|
| 460 |
`NiceMock<T>` only works for mock methods defined using the `MOCK_METHOD` macro |
| 461 |
directly in the definition of class `T`. If a mock method is defined in a base |
| 462 |
class of `T`, a warning might still be generated. |
| 463 |
|
| 464 |
`NiceMock<T>` might not work correctly if the destructor of `T` is not virtual. |
| 465 |
|
| 466 |
### NaggyMock {#NaggyMock} |
| 467 |
|
| 468 |
`::testing::NaggyMock<T>` |
| 469 |
|
| 470 |
Represents a mock object that generates warnings on |
| 471 |
[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The |
| 472 |
template parameter `T` is any mock class, except for another `NiceMock`, |
| 473 |
`NaggyMock`, or `StrictMock`. |
| 474 |
|
| 475 |
Usage of `NaggyMock<T>` is analogous to usage of `T`. `NaggyMock<T>` is a |
| 476 |
subclass of `T`, so it can be used wherever an object of type `T` is accepted. |
| 477 |
In addition, `NaggyMock<T>` can be constructed with any arguments that a |
| 478 |
constructor of `T` accepts. |
| 479 |
|
| 480 |
For example, the following code generates warnings on the mock `my_mock` of type |
| 481 |
`MockClass` if a method other than `DoSomething()` is called: |
| 482 |
|
| 483 |
```cpp |
| 484 |
using ::testing::NaggyMock; |
| 485 |
... |
| 486 |
NaggyMock<MockClass> my_mock("some", "args"); |
| 487 |
EXPECT_CALL(my_mock, DoSomething()); |
| 488 |
... code that uses my_mock ... |
| 489 |
``` |
| 490 |
|
| 491 |
Mock objects of type `T` by default behave the same way as `NaggyMock<T>`. |
| 492 |
|
| 493 |
### StrictMock {#StrictMock} |
| 494 |
|
| 495 |
`::testing::StrictMock<T>` |
| 496 |
|
| 497 |
Represents a mock object that generates test failures on |
| 498 |
[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The |
| 499 |
template parameter `T` is any mock class, except for another `NiceMock`, |
| 500 |
`NaggyMock`, or `StrictMock`. |
| 501 |
|
| 502 |
Usage of `StrictMock<T>` is analogous to usage of `T`. `StrictMock<T>` is a |
| 503 |
subclass of `T`, so it can be used wherever an object of type `T` is accepted. |
| 504 |
In addition, `StrictMock<T>` can be constructed with any arguments that a |
| 505 |
constructor of `T` accepts. |
| 506 |
|
| 507 |
For example, the following code generates a test failure on the mock `my_mock` |
| 508 |
of type `MockClass` if a method other than `DoSomething()` is called: |
| 509 |
|
| 510 |
```cpp |
| 511 |
using ::testing::StrictMock; |
| 512 |
... |
| 513 |
StrictMock<MockClass> my_mock("some", "args"); |
| 514 |
EXPECT_CALL(my_mock, DoSomething()); |
| 515 |
... code that uses my_mock ... |
| 516 |
``` |
| 517 |
|
| 518 |
`StrictMock<T>` only works for mock methods defined using the `MOCK_METHOD` |
| 519 |
macro directly in the definition of class `T`. If a mock method is defined in a |
| 520 |
base class of `T`, a failure might not be generated. |
| 521 |
|
| 522 |
`StrictMock<T>` might not work correctly if the destructor of `T` is not |
| 523 |
virtual. |
| 524 |
|
| 525 |
### Sequence {#Sequence} |
| 526 |
|
| 527 |
`::testing::Sequence` |
| 528 |
|
| 529 |
Represents a chronological sequence of expectations. See the |
| 530 |
[`InSequence`](#EXPECT_CALL.InSequence) clause of `EXPECT_CALL` for usage. |
| 531 |
|
| 532 |
### InSequence {#InSequence} |
| 533 |
|
| 534 |
`::testing::InSequence` |
| 535 |
|
| 536 |
An object of this type causes all expectations encountered in its scope to be |
| 537 |
put in an anonymous sequence. |
| 538 |
|
| 539 |
This allows more convenient expression of multiple expectations in a single |
| 540 |
sequence: |
| 541 |
|
| 542 |
```cpp |
| 543 |
using ::testing::InSequence; |
| 544 |
{ |
| 545 |
InSequence seq; |
| 546 |
|
| 547 |
// The following are expected to occur in the order declared. |
| 548 |
EXPECT_CALL(...); |
| 549 |
EXPECT_CALL(...); |
| 550 |
... |
| 551 |
EXPECT_CALL(...); |
| 552 |
} |
| 553 |
``` |
| 554 |
|
| 555 |
The name of the `InSequence` object does not matter. |
| 556 |
|
| 557 |
### Expectation {#Expectation} |
| 558 |
|
| 559 |
`::testing::Expectation` |
| 560 |
|
| 561 |
Represents a mock function call expectation as created by |
| 562 |
[`EXPECT_CALL`](#EXPECT_CALL): |
| 563 |
|
| 564 |
```cpp |
| 565 |
using ::testing::Expectation; |
| 566 |
Expectation my_expectation = EXPECT_CALL(...); |
| 567 |
``` |
| 568 |
|
| 569 |
Useful for specifying sequences of expectations; see the |
| 570 |
[`After`](#EXPECT_CALL.After) clause of `EXPECT_CALL`. |
| 571 |
|
| 572 |
### ExpectationSet {#ExpectationSet} |
| 573 |
|
| 574 |
`::testing::ExpectationSet` |
| 575 |
|
| 576 |
Represents a set of mock function call expectations. |
| 577 |
|
| 578 |
Use the `+=` operator to add [`Expectation`](#Expectation) objects to the set: |
| 579 |
|
| 580 |
```cpp |
| 581 |
using ::testing::ExpectationSet; |
| 582 |
ExpectationSet my_expectations; |
| 583 |
my_expectations += EXPECT_CALL(...); |
| 584 |
``` |
| 585 |
|
| 586 |
Useful for specifying sequences of expectations; see the |
| 587 |
[`After`](#EXPECT_CALL.After) clause of `EXPECT_CALL`. |