To start C unit testing with Google Test, you must first install and configure the framework correctly, then write a simple test case verification function, and finally organize the tests through the test fixture to improve maintainability. The specific steps include: 1. Select the installation method according to the operating system, such as Linux using package manager and CMake project to obtain from GitHub, Windows can be compiled with extensions or source code; 2. Write test cases, use TEST macro to define test cases and use EXPECT_EQ to assert; 3. Use the test fixture class to inherit::testing::Test and initialize the resources in the SetUp method, and reuse the environment through TEST_F; 4. Reasonably organize the test file structure, and it is recommended that each major component corresponds to a test file. Be sure to pay attention to the integrity of the link library and the clear design of the test logic.

If you're diving into C development, unit testing is a must-have skill — and Google Test (also known as gtest) is one of the most widely used frameworks for it. Setting up unit tests might feel like extra work at first, but once you get the rhythm, it saves time and headaches down the line.

Installing Google Test

Before writing tests, you need to set up Google Test in your project. There are a few ways to do this, depending on your environment.

• On Linux systems with package managers, you can often install it via commands like sudo apt-get install libgtest-dev .
• If you're using CMake, pulling Google Test from its GitHub repo and building it as part of your project is a solid approach.
• For Windows users, Visual Studio has extensions or you can build from source using CMake.

A common gotcha here is forgetting to link the library properly. Make sure you include both the main Google Test library and the pthread library if you're on Unix-like systems.

Writing Your First Test Case

Once everything's installed, start small: write a test case for a simple function.

Let's say you have a basic function:

 int add(int a, int b) {
    return ab;
}

Your corresponding test could look like this:

 #include <gtest/gtest.h>

TEST(MathTest, AdditionWorks) {
    EXPECT_EQ(add(2, 3), 5);
    EXPECT_EQ(add(-1, 1), 0);
}

Here's what's going on:

• TEST() is a macro that defines a test case.
• The first parameter ( MathTest ) is the test suite name.
• The second ( AdditionWorks ) is the individual test name.
• EXPECT_EQ checks for equality — if either check fails, the test reports a failure.

You can run all tests by adding this to your main file:

 int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

Organizing Tests with Test Fixtures

As your codebase grows, you'll want to reuse setup logic across multiple tests. That's where test fixtures come in handy.

Create a class derived from ::testing::Test , and override the SetUp() method:

 class StringTest : public ::testing::Test {
protected:
    std::string str;

    void SetUp() override {
        str = "hello";
    }
};

Now you can write multiple tests that use the same setup:

 TEST_F(StringTest, LengthIsCorrect) {
    EXPECT_EQ(str.length(), 5);
}

TEST_F(StringTest, ContentIsCorrect) {
    EXPECT_EQ(str, "hello");
}

This keeps your tests clean and avoids repetition. It also makes it easier to change setup logic later — just update one place instead of many.

One thing people often overlook is how to structure their test files. A good pattern is to create a separate .cpp file for each major component or class you're testing. This keeps things manageable and avoids huge, messy test files.

Basically that's it.

The above is the detailed content of C tutorial on unit testing with Google Test. For more information, please follow other related articles on the PHP Chinese website!