Migliori Pratiche per Test unità di scrittura per C Code

Scrivere efficaci casi di prova: il modello Arrange-Act‐Assert

Ogni test di unità deve seguire una chiara struttura a tre fasi, che a volte è chiamata “triple‐A”, rende i test facili da leggere e debug.

1. Arrange[] – Impostare le condizioni prestabilite: inizializzare le variabili, allocare la memoria, impostare le aspettative di mock, configurare lo stato globale (se non desiderabile), e creare i dati di input.
2. Atti[] – Chiamare la funzione sotto test con gli input disposti.
3. Assert[] – Verificare che il valore restituito, le interazioni dello stato modificato o del mock corrispondano ai risultati attesi.

Esempio utilizzando Unity:

#include "unity.h"
#include "math_utils.h"

void setUp(void) {}
void tearDown(void) {}

void test_add_positive_numbers(void) {
 // Arrange
 int a = 2;
 int b = 3;

 // Act
 int result = add(a, b);

 // Assert
 TEST_ASSERT_EQUAL_INT(5, result);
}

Si noti che il nome del test è descrittivo[]: ti dice immediatamente quale scenario viene testato.

Convenzioni e commenti di denominazione

Un buon nome della funzione di test segue un modello come (ad esempio ]). Il test, tenere commenti al minimo, il codice dovrebbe essere auto-documentazione. Tuttavia, se la configurazione richiede una sequenza complessa (ad esempio, la costruzione di un elenco collegato con 1000 nodi), un breve commento spiegando perché tale particolare disposizione è stata scelta è utile.

Test di struttura per l'isolamento

L'isolamento è la parte più difficile del codice C di prova unità, soprattutto quando le dipendenze coinvolgono variabili globali, funzioni statiche o registri hardware. L'obiettivo è quello di sostituire le dipendenze reali con doppi test (mock, stubs, o falsi).

Incidere e stubbing in Pure C

Collegamento contro una libreria di mock può essere fatto a tempo di compilazione utilizzando un trucco di fascia di linker. Ad esempio, con CMocka, è possibile creare una funzione di mock e quindi istruire il linker per usarlo invece di quello reale:

int __wrap_send_to_hardware(int data) {
 // Record the call and return a predetermined value
 check_expected(data);
 return mock_type(int);
}

Poi, quando si collega l'eseguibile di prova, si aggiunge alle bandiere di collegamento. Il reale [] è sostituito dal vostro wrapper durante la prova. Questa tecnica è dettagliata nell'articolo LWN sul fasciatore di collegamento per il doppio di prova.

Trattare con Global State

Se i globali sono inevitabili, usare e ] per salvare e ripristinare i loro valori. Alcuni framework (come Check) eseguire ogni prova in un processo a forche separate, che isola naturalmente lo stato ma aumenta in testa.

Custodia per bordi e gestione degli errori

I bug di produzione spesso si accumulano negli angoli: puntatori nulli, array vuoti, valori limite e codici di ritorno degli errori. Una robusta suite di test include test che guidano deliberatamente il codice in questi stati.

Bordo comune per funzioni C

• Null pointers[[] – La funzione si blocca? Risponde o un codice di errore?
• I buffer di lunghezza zero[[] – Può la funzione gestire gli input della dimensione 0?
• Valori massimi e minimi di integer[[ – Overflow, underflow, firme / non firmate.
• Insufficienza di allocazione di memoria[[] – Simula un fallito ] utilizzando un allocatore personalizzato o mock.
• Condizioni corporative sui loop[ – Esattamente 0 iterazioni, esattamente 1 iterazione, il massimo conteggio di iterazione permesso.
• Codici di errore dalle funzioni sottostanti[ – ] ]], []] ritornando un conteggio parziale.

Ecco un esempio di testare una bordatura con Unity:

void test_parse_config_null_path(void) {
 // Arrange
 const char* path = NULL;

 // Act
 ConfigResult result = parse_config(path);

 // Assert
 TEST_ASSERT_EQUAL(CONFIG_ERR_NULL_POINTER, result.error);
}

Non presumiamo che gli input “normali” siano sempre usati. La prova di percorsi felici evidenti è meno preziosa che coprire un ampio insieme di condizioni di errore.

Automazione dei tuoi test in una tubatura CI

I test delle unità sono più efficaci quando vengono eseguiti automaticamente su ogni commit. L'integrazione continua (CI) assicura che le regressioni siano catturate entro pochi minuti, non giorni. Per i progetti C, l'impostazione CI con strumenti open source è semplice.

Esempio: GitHub Azioni con CMake

Creare un file :

name: C Unit Tests
on: [push, pull_request]
jobs:
 test:
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v4
 - name: Install dependencies
 run: sudo apt-get install -y cmake gcc lcov
 - name: Configure and build
 run: |
 mkdir build && cd build
 cmake .. -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTS=ON
 make
 - name: Run tests
 run: cd build && ctest --output-on-failure
 - name: Generate coverage report
 run: cd build && lcov --capture --directory . --output-file coverage.info && genhtml coverage.info --output-dir coverage

Questo flusso di lavoro compila il progetto, esegue i test unitari con CTest e produce un report di copertura del codice. È quindi possibile pubblicare il report di copertura come artefatto. Per una guida completa sull'integrazione CI, vedere la GitHub Azioni documentazione per C/C++.

Mantenere e Coinvolgere la vostra suite di test

Le prove superate che passano sempre o che non vengono mai aggiornate diventano rumore e si erosigono fiducia. Seguire queste pratiche per garantire che la tua suite di test rimanga preziosa: