GoogleTest

gMock is Google's C++ framework for creating and using mock classes. It is designed to help developers derive better system designs and write more effective tests by providing a declarative syntax for defining mocks and controlling their behavior.

Key capabilities include:

• Declarative Mock Definition: Define mock objects using a specialized syntax.
• Partial (Hybrid) Mocks: Create objects that combine real implementation with mocked behavior.
• Complex Function Support: Handles overloaded functions and functions of arbitrary types.
• Rich Matcher Set: Validate function arguments using a wide variety of built-in matchers.
• Behavior Control: Use intuitive syntax to specify how mocks should respond to calls.
• Automatic Verification: Expectations are verified automatically (no manual record-and-replay required).
• Ordering Constraints: Express arbitrary (partial) ordering constraints on function calls.
• Extensibility: Users can define custom matchers and actions.
• No Exceptions: The framework does not rely on C++ exceptions.

When testing multiple implementations of the same interface, choose based on how instances are created and how you want failure information reported:

Tip: If using value-parameterized tests, pass a function that returns an iteration name as the third parameter to INSTANTIATE_TEST_SUITE_P to improve debuggability.

Type-parameterized tests allow you to define test logic once and instantiate it with different sets of types later. This is useful for verifying that different implementations of an interface or concept all satisfy the same requirements without duplicating test code.

To implement them:

1. Define a fixture class template.
2. Declare the suite using TYPED_TEST_SUITE_P(FixtureName).
3. Define tests using TYPED_TEST_P(FixtureName, TestName). Inside these tests, use TypeParam to refer to the current type.
4. Register the test patterns using REGISTER_TYPED_TEST_SUITE_P(FixtureName, Test1, Test2, ...).
5. Instantiate the suite with specific types using INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, FixtureName, TypeList).

// 1. Define fixture template
template <typename T>
class FooTest : public testing::Test {
  void DoSomethingInteresting();
};

// 2. Declare suite
TYPED_TEST_SUITE_P(FooTest);

// 3. Define tests
TYPED_TEST_P(FooTest, DoesBlah) {
  TypeParam n = 0;
  this->DoSomethingInteresting();
}

// 4. Register patterns
REGISTER_TYPED_TEST_SUITE_P(FooTest, DoesBlah);

// 5. Instantiate
using MyTypes = ::testing::Types<char, int, unsigned int>;
INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);

An "uninteresting call" is a call to a mock method that has no corresponding EXPECT_CALL. By default, gMock prints a warning for these. You can change this behavior on a per-mock-object basis:

• NiceMock<T>: Suppresses warnings for uninteresting calls. Use this most of the time to keep tests clean.
• StrictMock<T>: Treats uninteresting calls as failures. Use this only as a last resort, as it makes tests brittle.
• Default (Naggy): Prints a warning for uninteresting calls. Useful during active development/debugging.

Note: These modifiers only work if the MOCK_METHOD is defined directly in the mock class (not in a base class) and if the mock class has a virtual destructor.

using ::testing::NiceMock;
using ::testing::StrictMock;

TEST(MyTest, Example) {
  NiceMock<MockFoo> nice_foo;
  StrictMock<MockFoo> strict_foo;
  
  // nice_foo will not warn if methods other than those expected are called.
  // strict_foo will fail if any method other than those expected is called.
}

A common pitfall is assuming ASSERT_* or FAIL* aborts the entire test. In reality, they only abort the current function. If an ASSERT_* fails inside a subroutine, the caller will continue execution, which can lead to crashes (e.g., dereferencing a null pointer).

To handle this, you have three main options:

1. Use ASSERT_NO_FATAL_FAILURE(statement): This macro checks if the statement generated any fatal failures in the current thread. If it did, the assertion fails and aborts the current test.
2. Use HasFatalFailure(): Manually check if a fatal failure has occurred and return early from the caller.
3. Use Exceptions: Implement a custom testing::EmptyTestEventListener that throws a testing::AssertionException when a fatal failure occurs.

// Option 1: Using ASSERT_NO_FATAL_FAILURE
ASSERT_NO_FATAL_FAILURE(Foo());

// Option 2: Using HasFatalFailure() to return early
TEST(FooTest, Bar) {
  Subroutine();
  if (HasFatalFailure()) return;
  // The following won't be executed if Subroutine() had a fatal failure.
}

Death tests verify that a piece of code causes the process to terminate. GoogleTest executes the code in a child process to prevent the main test runner from dying.

Key Assertions

• EXPECT_DEATH(statement, matcher): Verifies statement causes the process to terminate with a nonzero exit status and produces stderr output matching matcher. A bare string matcher is treated as a regex (ContainsRegex).
• EXPECT_DEATH_IF_SUPPORTED(statement, matcher): Behaves like EXPECT_DEATH if supported by the platform; otherwise, does nothing.
• EXPECT_DEBUG_DEATH(statement, matcher): Behaves like EXPECT_DEATH in debug mode; in NDEBUG mode, it simply executes the statement.
• EXPECT_EXIT(statement, predicate, matcher): Verifies statement terminates with an exit status satisfying predicate and stderr matching matcher.

Exit Status Predicates

• ::testing::ExitedWithCode(exit_code): Returns true if the program exited normally with the given code.
• ::testing::KilledBySignal(signal_number): Returns true if the program was killed by a specific signal (not available on Windows).

Death Test Styles

Controlled by the --gtest_death_test_style flag (default is "fast"):

• "fast": (POSIX) Uses fork()/clone() and executes the statement immediately in the child.
• "threadsafe": (POSIX/Windows) Re-executes the test binary in the child to ensure a clean environment.

// Verify process dies with specific error message
EXPECT_DEATH(DoSomething(42), "My error");

// Verify process exits with code 0 and specific message
EXPECT_EXIT(NormalExit(), testing::ExitedWithCode(0), "Success");

// Compound statements in death tests
EXPECT_DEATH({
  int n = 5;
  DoSomething(&n);
}, "Error on line .* of DoSomething()");