Revision history [back]

There are a few steps to follow when testing a callback function written in C using googletest gmock:

1. Write the callback function: Start by writing a basic callback function with one or more input parameters and an output value.

2. Define the mock function: In order to test the callback function, you will need to create a mock function that mimics the behavior of the real function.

3. Set up the test environment: Create a test fixture class that sets up the test environment and provides the necessary objects for testing the function.

4. Specify the expectations: Use gmock to specify the expectations for the callback function. For example, you might expect the mock function to be called a certain number of times, with specific input values.

5. Test the code: Run the test and verify that the callback function behaves as expected.

Here is an example code:

// The callback function to be tested
int my_callback(int a, int b) {
  return a + b;
}

// Define the mock function
class MockCallbacks {
 public:
  MOCK_METHOD(int, my_callback, (int, int));
};

// Set up the test environment
class CallbackTest : public ::testing::Test {
 public:
  void SetUp() override {
    // Initialize the mock function
    mock_callbacks_ = std::make_unique<MockCallbacks>();
  }

  std::unique_ptr<MockCallbacks> mock_callbacks_;
};

// Test the callback function
TEST_F(CallbackTest, TestMyCallback) {
  // Specify the expectations for the mock function
  EXPECT_CALL(*mock_callbacks_, my_callback(4, 6)).WillOnce(Return(10));
  EXPECT_CALL(*mock_callbacks_, my_callback(2, 8)).WillOnce(Return(10));

  // Call the callback function using the mock function
  int result1 = mock_callbacks_->my_callback(4, 6);
  int result2 = mock_callbacks_->my_callback(2, 8);

  // Verify that the callback function behaved as expected
  EXPECT_EQ(result1, 10);
  EXPECT_EQ(result2, 10);
}

In this example, the callback function simply adds two integers together. The mock function is defined using the gmock MOCK_METHOD macro, which creates a mock function with the same signature as the callback function.

In the CallbackTest fixture class, the mock function is initialized using std::make_unique<MockCallbacks>(). In the TestMyCallback test case, two expectations are specified using the EXPECT_CALL macro. These expectations specify the input parameters and expected return value for the mock function.

After calling the callback function using the mock function, the test verifies that the callback function returned the expected result using the EXPECT_EQ macro.