Unit testing and Test driven development

In the world of programming, errors are inevitable. Even the most experienced developers make mistakes. But fear not, for unit testing comes to the rescue! Unit testing is a technique used by developers to verify the correctness of individual units or components of a software system. In this chapter, we will explore the concept of unit testing specifically tailored for the C programming language.

What are Unit Tests?

Unit tests are small, automated tests that validate the behavior of individual units of code, typically functions or methods. The goal is to isolate each piece of code and verify that it performs as expected under various conditions. By writing unit tests, developers can catch bugs early in the development cycle, improve code quality, and facilitate easier maintenance.

Introduction to Test Driven Development (TDD)

Test Driven Development (TDD) is a software development methodology where tests are written before the actual code implementation. This approach ensures that the code meets the specified requirements and remains robust throughout the development process. In TDD, developers write small tests to define the desired behavior of a piece of code and then implement the code to pass those tests.

Basic Concepts of TDD

Red-Green-Refactor Cycle

Red: Write a test that fails initially, as there’s no implementation code.
Green: Implement the code to make the test pass.
Refactor: Optimize the code without changing its behavior.

Unit Tests

Tests written to validate the smallest units of code, typically functions or methods.
These tests focus on a specific piece of functionality.

Assertions

Statements within tests that verify specific conditions.
If an assertion fails, the test fails.

Setting up TDD Environment in C

Before diving into writing unit tests, it’s essential to set up a testing environment. For C programming, we’ll use a popular unit testing framework called cmocka. First, download and install cmocka according to the instructions provided on its website or package manager. Once installed, you’re ready to start writing and executing unit tests.

Choose a Testing Framework

Select a testing framework like Unity or CUnit for writing and running tests.

Project Structure

Organize your project with separate directories for source code and tests.

Integration with Build System

Integrate the testing framework with your build system (e.g., Makefile) for seamless execution.

Setting Up Unit Testing Environment

Writing Your First Unit Test

Let’s create a simple C program with a function that adds two numbers:

				
					// add.c
#include <stdio.h>

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

int main() {
    int result = add(3, 4);
    printf("Result: %d\n", result);
    return 0;
}

Now, let’s write a unit test for the add function using cmocka:

				
					// test_add.c
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>

#include "add.c"

static void test_add(void **state) {
    (void) state; // unused

    assert_int_equal(add(3, 4), 7);
}

int main() {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_add),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}

In this test, we include the add.c file to access the add function. We then define a test function test_add, where we use assert_int_equal macro to check if the result of add(3, 4) is equal to 7.

Compiling and Running Unit Tests

To compile our unit test program, we use a C compiler along with cmocka library:

				
					gcc -o test_add test_add.c -lcmocka

To compile our unit test program, we use a C compiler along with cmocka library:

				
					./test_add

You should see the output indicating whether the test passed or failed.

Advanced Techniques in Unit Testing

Mocking

Mocking is a powerful technique in unit testing, particularly when dealing with dependencies such as external libraries, databases, or APIs. Mock objects simulate the behavior of these dependencies, allowing you to isolate the unit under test and focus solely on its logic.

Consider a scenario where a function interacts with a database. Instead of actually connecting to the database during testing, you can use a mock object that mimics the database’s behavior. This way, you can control the responses and test various scenarios without relying on external resources.

				
					// Original function
int get_user_balance(const char* username) {
    // Connect to the database and retrieve user balance
}

// Test using mock object
void test_get_user_balance(void **state) {
    // Set up mock database with predefined user balances
    // Call get_user_balance with different usernames
    // Verify the returned balances against expected values
}

Parameterized Tests

Parameterized tests allow you to run the same test logic with multiple inputs, making your test suite more concise and versatile. Instead of writing separate tests for each input, you can define a single test and provide different parameters for each execution.

Parameterized tests are particularly useful when testing functions with a range of inputs or boundary conditions.

				
					// Original function
int factorial(int n) {
    // Calculate the factorial of n
}

// Parameterized test
void test_factorial(void **state) {
    int input = *((int*) *state);
    int expected_output = *((int*) *(state + 1));
    assert_int_equal(factorial(input), expected_output);
}

int main() {
    int test_cases[][2] = {
        {0, 1},
        {1, 1},
        {5, 120},
        // More test cases...
    };

    for (int i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) {
        const struct CMUnitTest test = cmocka_unit_test(test_factorial, &test_cases[i]);
        cmocka_run_group_tests(&test, NULL, NULL);
    }

    return 0;
}

Test Fixtures

Test fixtures provide a way to set up a common environment for multiple tests. This is useful when several tests require the same initialization steps or share resources. By creating a fixture, you can avoid duplicating setup code in each test and ensure consistency across the test suite.

				
					// Fixture setup
void setup(void **state) {
    // Initialize common resources
    *state = // Initialize shared data
}

// Fixture teardown
void teardown(void **state) {
    // Clean up resources
}

// Test using fixture
void test_function_1(void **state) {
    // Access shared data and perform test
}

void test_function_2(void **state) {
    // Access shared data and perform test
}

int main() {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test_setup_teardown(test_function_1, setup, teardown),
        cmocka_unit_test_setup_teardown(test_function_2, setup, teardown),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}

These advanced techniques enhance the effectiveness and efficiency of your unit testing efforts, allowing you to catch more bugs and ensure the reliability of your C code. By mastering these techniques, you can build robust and maintainable software with confidence.

Unit testing is a vital practice in software development, ensuring the reliability and correctness of code. By writing and running unit tests regularly, developers can build robust and maintainable C programs with confidence. This chapter covered the fundamentals of unit testing in C, from the basics of writing tests to advanced techniques like mocking and parameterized testing. With cmocka and the knowledge gained from this chapter, you're equipped to test your C code effectively and ensure its quality. Happy coding !❤️