Embedded Prep

Unit Testing Frameworks : Unit testing is a software development practice where individual units or components of a program are tested to ensure they behave as expected. In embedded systems, especially when working with complex software, it becomes critical to verify the correctness of small parts of the code independently. Unit testing frameworks help automate this process, making it easier and more reliable.

One of the most popular unit testing frameworks is Google Test, which is widely used for testing C++ code. In this article, we’ll explore Google Test, how to set it up, and how to write basic unit tests.

Introduction to Unit Testing Frameworks

What is Google Test?

Google Test (also known as gtest) is an open-source C++ testing framework developed by Google. It helps developers write and run tests to verify their code. It is designed to be simple, easy to use, and integrate into different types of C++ projects, including embedded systems, application software, and libraries.

Some features of Google Test include:

• Assertions: Google Test provides various types of assertions to check if your code behaves as expected (e.g., EXPECT_EQ(), ASSERT_EQ()).
• Test Fixtures: You can set up common test data and configuration before running tests.
• Parameterized Tests: You can run tests with different inputs, improving test coverage.

Setting Up Google Test

Before you can use Google Test in your project, you need to set it up. Here’s a simple guide on how to integrate it into your C++ project.

Step 1: Install Google Test

To install Google Test, follow these steps:

1. Clone the Google Test repository from GitHub: git clone https://github.com/google/googletest.git cd googletest
2. Build Google Test:
   If you’re using CMake (which is common in embedded development), you can build it as follows: mkdir build cd build cmake .. make sudo make install

Step 2: Include Google Test in Your Project

In your C++ project, link the Google Test library and include the necessary headers.

1. Include the header file in your test source code: #include <gtest/gtest.h>
2. Link the Google Test library during the compilation. If you’re using CMake, your CMakeLists.txt file would look something like this: find_package(GTest REQUIRED) include_directories(${GTEST_INCLUDE_DIRS}) add_executable(my_tests test.cpp) target_link_libraries(my_tests ${GTEST_LIBRARIES} pthread)

Writing Your First Unit Test

Now that you have Google Test set up, it’s time to write your first unit test.

Example: Testing a Simple Function

Let’s assume we have a simple function that adds two numbers:

int Add(int a, int b) {
    return a + b;
}

1. write test cases

#include <gtest/gtest.h>

// Function to be tested
int Add(int a, int b) {
    return a + b;
}

// Test case
TEST(AdditionTest, HandlesPositiveInput) {
    EXPECT_EQ(Add(2, 3), 5);  // Assert that 2 + 3 equals 5
}

TEST(AdditionTest, HandlesNegativeInput) {
    EXPECT_EQ(Add(-2, -3), -5);  // Assert that -2 + -3 equals -5
}

TEST(AdditionTest, HandlesZeroInput) {
    EXPECT_EQ(Add(0, 0), 0);  // Assert that 0 + 0 equals 0
}

// Main function to run the tests
int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

1. Compile and run the tests:
   Use the following command to compile your test code: g++ -std=c++11 -isystem /path/to/gtest/include -pthread test.cpp /path/to/gtest/libgtest.a -o test_program ./test_program If everything is set up correctly, Google Test will run your tests and display the results.

Assertions in Google Test

Google Test provides various types of assertions to verify the results of your code. Some commonly used assertions include:

• EXPECT_EQ(val1, val2): Checks if two values are equal.
• EXPECT_NE(val1, val2): Checks if two values are not equal.
• ASSERT_TRUE(condition): Checks if the condition is true.
• ASSERT_FALSE(condition): Checks if the condition is false.
• EXPECT_LT(val1, val2): Checks if val1 is less than val2.
• EXPECT_GT(val1, val2): Checks if val1 is greater than val2.

Here’s an example of using assertions:

TEST(SubtractionTest, HandlesPositiveInput) {
    EXPECT_EQ(Add(5, 3), 8);  // Passes
    ASSERT_FALSE(Add(5, 3) == 7);  // Passes, checks that 5 + 3 is not equal to 7
}

Running Tests and Viewing Results

After compiling and running the tests, Google Test will display the results in the terminal. It will show whether each test passed or failed. If a test fails, it provides details on the failure, such as which assertion failed and the values involved.

For example, if the Add() function is incorrect, Google Test will display:

[ RUN      ] AdditionTest.HandlesPositiveInput
test.cpp:9: Failure
Expected equality of these values:
  Add(2, 3)
    Which is: 4
  5
[  FAILED  ] AdditionTest.HandlesPositiveInput (0 ms)

Test Fixtures

Test fixtures allow you to set up common test data or objects that are shared across multiple test cases. This is useful for avoiding code duplication.

Example:

class AdditionTest : public ::testing::Test {
protected:
    int a = 2;
    int b = 3;
};

TEST_F(AdditionTest, HandlesPositiveInput) {
    EXPECT_EQ(Add(a, b), 5);
}

Conclusion

Google Test is a powerful and flexible unit testing framework that can help you ensure the correctness of your code. By writing automated tests, you can catch bugs early and ensure your software behaves as expected. For embedded systems and other C++ projects, Google Test makes testing easy and efficient.

In this article, we introduced the basics of setting up and using Google Test, writing test cases, using assertions, and running tests. By integrating unit tests into your development workflow, you’ll improve the reliability and maintainability of your software.

Basic Questions

1. What is Google Test (gtest)?
   • Explain what Google Test is and its key features.
2. What are the advantages of using Google Test in C++ projects?
   • Discuss the benefits of using Google Test over manual testing or other testing frameworks.
3. How do you install and set up Google Test in a C++ project?
   • Describe the process of installing and integrating Google Test with a project using either CMake or Makefiles.
4. What is the difference between ASSERT_* and EXPECT_* in Google Test?
   • Explain when to use ASSERT_* and EXPECT_* assertions.
5. What is a test fixture in Google Test?
   • Describe what a test fixture is and provide an example use case.
6. Can you explain the structure of a basic Google Test test case?
   • How do you write a simple test case using TEST or TEST_F?
7. What is the role of the main function in Google Test?
   • What does the main function do in a Google Test framework?
8. What is a parameterized test in Google Test, and how do you implement one?
   • Explain what parameterized tests are and how to use the INSTANTIATE_TEST_SUITE_P macro.
9. What is the difference between RUN_ALL_TESTS() and RUN_ALL_TESTS() in Google Test?
   • Explain the differences in test execution control in Google Test.
10. How do you handle exceptions in Google Test?
    • Can Google Test catch and test exceptions thrown by your code?

Intermediate Questions

11. Explain the concept of test cases and test suites in Google Test.
    • What is a test case and how does it fit into a test suite?
12. How do you organize multiple tests in Google Test for better readability and maintenance?
    • Discuss strategies for organizing tests, such as naming conventions or categorizing tests into test suites.
13. How would you implement mock objects in Google Test?
    • Explain how Google Mock can be used alongside Google Test to mock dependencies for unit testing.
14. How do you perform performance testing using Google Test?
    • Is it possible to use Google Test for performance benchmarking, and if so, how?
15. What are the best practices for writing effective unit tests using Google Test?
    • Discuss the best practices such as keeping tests small, independent, and readable.
16. How do you integrate Google Test with continuous integration (CI) tools like Jenkins?
    • Describe the process of integrating Google Test results into a CI/CD pipeline.
17. Explain how to run Google Test on embedded systems (such as ARM or RTOS) and handle cross-compilation.
    • Discuss challenges and solutions for running Google Test in embedded environments.
18. How would you debug a failing test in Google Test?
    • What strategies do you use to diagnose and fix failing tests in Google Test?
19. What are the types of assertions available in Google Test, and when would you use each one?
    • Provide a list of assertions such as EXPECT_EQ, EXPECT_NE, ASSERT_TRUE, and their appropriate use cases.
20. How can you use Google Test to test multithreaded code?
    • Explain how to write tests for code involving threads and concurrency.

Advanced Questions

21. What are Google Test’s test discovery and test filtering mechanisms?
    • How can you control which tests to run using test discovery and filtering options?
22. What are the advantages of using Google Test over other unit testing frameworks like Catch2 or Boost.Test?
    • Compare and contrast Google Test with other popular C++ testing frameworks.
23. Can you explain Google Test’s DeathTest feature?
    • What is a “Death Test,” and when would you use it in Google Test?
24. How do you test code that interacts with hardware or I/O in Google Test?
    • Discuss techniques for testing hardware-dependent code in unit tests, such as mocking hardware APIs.
25. How would you create custom assertions in Google Test?
    • Describe how to create custom assertions to extend Google Test’s built-in functionality.
26. How do you handle memory management issues in tests?
    • Discuss strategies for managing memory leaks and other memory issues when running tests in Google Test.
27. How do you use Google Test with a version-controlled project (e.g., Git)?
    • Discuss strategies for using Google Test in teams, version control, and managing test cases.
28. Explain the role of Google Test in TDD (Test-Driven Development).
    • How does Google Test support the Test-Driven Development approach in embedded software?
29. How would you mock external dependencies (e.g., databases, network calls) in Google Test?
    • Provide examples of mocking external systems to isolate the unit being tested.
30. How do you optimize the runtime of Google Test when testing large codebases?
    • Discuss techniques for reducing the time it takes to run tests, such as test grouping or test prioritization.

You can also Visit other tutorials of Embedded Prep 

• What is eMMC (Embedded MultiMediaCard) memory ?
• Top 30+ I2C Interview Questions
• Bit Manipulation Interview Questions
• Structure and Union in c
• Little Endian vs. Big Endian: A Complete Guide
• Merge sort algorithm

Special thanks to @mr-raj for contributing to this article on EmbeddedPrep