Mastering GTest: A Clarification of Call() in EXPECT_CALL

When it comes to unit testing in C++, Google Test (also known as GTest) is one of the most popular and widely-used frameworks. One of the key features of GTest is the ability to mock functions and set expectations for their behavior using the EXPECT_CALL macro. However, one of the most common points of confusion for developers new to GTest is the Call() function, and how it fits into the EXPECT_CALL syntax. In this article, we’ll delve deep into the world of GTest and provide a clear clarification of Call() in EXPECT_CALL, so you can write more effective unit tests and take your C++ development skills to the next level.

What is EXPECT_CALL?

Briefly, EXPECT_CALL is a macro in GTest that allows you to set expectations for how a mock function will be called during a test. It’s a powerful tool for verifying that your code is interacting with dependencies in the way you expect. The basic syntax for EXPECT_CALL is as follows:

EXPECT_CALL(mock_object, function_name(arguments))
    .Times(number_of_times_expected)
    .WillOnce(action)

In this example, we’re setting an expectation that the function function_name will be called on the mock_object exactly number_of_times_expected times, with the specified arguments. The WillOnce action specifies what should happen when the function is called.

What is Call()?

Now, let’s talk about Call(). Call() is a function in GTest that allows you to specify a specific call to a mock function, along with any required arguments. It’s often used in conjunction with EXPECT_CALL to specify the exact call that you’re expecting.

EXPECT_CALL(mock_object, function_name(Call(&argument)))

In this example, we’re using Call() to specify that we expect the function function_name to be called with the argument &argument.

How Does Call() Fit into EXPECT_CALL?

So, how does Call() fit into the EXPECT_CALL syntax? The short answer is that Call() is used to specify the exact call that you’re expecting, including any required arguments.

Let’s take a look at an example:

class MockDatabase {
 public:
  MOCK_METHOD(void, Query, (std::string), (override));
};

TEST(FooTest, QueryCalls) {
  MockDatabase mock_db;
  EXPECT_CALL(mock_db, Query(Call("SELECT * FROM table")));
  Foo foo;
  foo.QueryDatabase(&mock_db);
}

In this example, we’re setting an expectation that the Query function will be called on the mock_db object with the argument “SELECT * FROM table”. When the Foo object calls QueryDatabase, which in turn calls Query on the mock_db object, the expectation will be satisfied.

Using Call() with Multiple Arguments

What if the function you’re mocking takes multiple arguments? No problem! You can use Call() with multiple arguments by passing them as separate arguments to the Call() function.

EXPECT_CALL(mock_db, Query(Call("SELECT * FROM table"), Call(10)))

In this example, we’re setting an expectation that the Query function will be called with the arguments “SELECT * FROM table” and 10.

Using Call() with Matchers

What if you want to set an expectation for a function call, but you don’t care about the exact value of one or more of the arguments? That’s where matchers come in. Matchers are a powerful feature in GTest that allow you to specify flexible expectations for function calls.

EXPECT_CALL(mock_db, Query(Call("SELECT * FROM table"), NotNull()))

In this example, we’re setting an expectation that the Query function will be called with the argument “SELECT * FROM table”, and any non-null value as the second argument.

Common Pitfalls to Avoid

When using Call() in EXPECT_CALL, there are a few common pitfalls to avoid:

• Make sure to use the correct number of arguments. If the function you’re mocking takes three arguments, you need to pass three arguments to Call()
• Be careful with argument types. Make sure the types of the arguments you pass to Call() match the types of the arguments expected by the mock function
• Don’t forget to use Call() with EXPECT_CALL. Call() is only valid when used in conjunction with EXPECT_CALL

Best Practices for Using Call()

Here are some best practices to keep in mind when using Call() in EXPECT_CALL:

• Use Call() sparingly. Only use Call() when you need to specify a specific call to a mock function. For most cases, the default behavior of EXPECT_CALL is sufficient
• Use matchers when possible. If you don’t care about the exact value of an argument, consider using a matcher to make your test more flexible
• Keep your EXPECT_CALL syntax readable. Use whitespace and line breaks to make your EXPECT_CALL syntax easy to read and understand

Conclusion

In this article, we’ve provided a clear clarification of Call() in EXPECT_CALL, and shown how to use it to write more effective unit tests with GTest. By mastering the use of Call() and EXPECT_CALL, you can write more robust and reliable unit tests, and take your C++ development skills to the next level.

Frequently Asked Questions

Q: What is the difference between Call() and Times()?

A: Call() is used to specify the exact call to a mock function, including any required arguments. Times() is used to specify the number of times a mock function is expected to be called.

Q: Can I use Call() with non-mock functions?

A: No, Call() is only valid when used with mock functions.

Q: How do I use Call() with multiple return values?

A: You can use Call() with multiple return values by passing multiple values as separate arguments to the Call() function.

Keyword	Description
EXPECT_CALL	Macro in GTest for setting expectations for mock function calls
Call()	Function in GTest for specifying a specific call to a mock function
Matchers	Feature in GTest for specifying flexible expectations for function calls

Frequently Asked Question

Get ready to clarify the mysteries of Call() in gtest EXPECT_CALL!