Skip to content
Torna ai risultati

Analisi della copertura del codice

Introdotto da
Test Coverage Community
Anno
1988
Tipo
measurement and analysis
Famiglia
Test measurement

Questo testo è una traduzione automatica e non è ancora stato revisionato. Leggi l’originale in inglese

Dimensione del carattere

A cosa serve?

L'analisi della copertura del codice misura l'estensione con cui il codice sorgente viene eseguito da una suite di test, quantificando quali righe, rami o percorsi vengono esercitati.

Gli strumenti strumentano il codice per tracciare l'esecuzione, riportando percentuali di copertura e identificando regioni non testate. L'analisi della copertura guida la creazione dei test, rileva il codice morto e valida l'adeguatezza dei test nei processi di assicurazione della qualità.

L’intuizione alla base del metodo

Una suite di test trova bug solo nel codice che esegue effettivamente. La copertura risponde: quali regioni di codice esercita la suite di test e quali rimangono non testate? Un'elevata copertura suggerisce che la suite di test ha un'ampia portata; una bassa copertura espone lacune dove i bug potrebbero annidarsi inosservati. Le metriche di copertura consentono ai team di identificare quali moduli necessitano di test più rigorosi.

Storia

I concetti di copertura del codice sono emersi negli anni '70-'80 con lo sviluppo di metodologie di test formali. La survey di Zhu, Hall e May del 1997 ha formalizzato la tassonomia dei criteri di copertura (istruzione, ramo, percorso, flusso di dati). I primi strumenti richiedevano la modifica del codice sorgente; la strumentazione moderna (JaCoCo, Clover, Istanbul) opera in modo trasparente. La copertura è diventata standard nelle pratiche DevOps, con coverage.py, Istanbul e servizi cloud come Codecov che integrano il reporting automatizzato. Il dibattito continua se le percentuali di copertura guidino miglioramenti della qualità o creino semplicemente una falsa sicurezza.

Quando usarlo

Applicare l'analisi della copertura del codice come quality gate nelle pipeline di integrazione continua. Utilizzare per identificare codice morto, guidare la prioritizzazione dei casi di test e validare la completezza dei test prima del rilascio. La copertura funziona meglio come strumento diagnostico piuttosto che come requisito rigoroso; soglie di copertura estremamente elevate possono incoraggiare test controproducenti. Ideale per sistemi critici per la sicurezza e altamente affidabili dove la completezza è fondamentale.

Limiti e considerazioni

  • Un'elevata copertura non garantisce un'elevata qualità dei test; un'ampia copertura delle righe può coesistere con una logica di asserzione debole
  • Le metriche di copertura non misurano l'efficacia; coprire una riga con un test è inutile se il test non effettua asserzioni
  • Diversi tipi di copertura (riga, ramo, percorso) misurano cose diverse; nessuna singola metrica è sufficiente per una comprensione completa
  • Esplosione della copertura dei percorsi: la copertura esaustiva dei percorsi diventa infattibile in programmi con molti rami condizionali

Le condizioni della fonte non sostituiscono una revisione scientifica indipendente né la validazione da parte di un motore di analisi.

Punti di forza

  • Fornisce una misurazione oggettiva dell'ampiezza della suite di test, indipendente dalla valutazione soggettiva della qualità dei test
  • Identifica percorsi di codice inutilizzati idonei alla rimozione, semplificando la manutenzione
  • Si integra perfettamente nelle pipeline automatizzate di build e test
  • Supporta decisioni informate sull'investimento nei test: quali moduli necessitano di test più approfonditi

Applicazioni

  • Identificare codice morto in sistemi finanziari legacy di 10 anni con milioni di righe, consentendo la rimozione sicura e riducendo il carico cognitivo durante la manutenzione
  • Validare la completezza della suite di test in software sanitario critico dove la conformità normativa richiede prove di test approfonditi prima del deployment
  • Rilevare percorsi di gestione degli errori non sfruttati in software di infrastruttura per telecomunicazioni esaminando gestori di eccezioni non coperti che potrebbero mascherare fallimenti silenziosi
  • Prioritizzare lo sforzo di test nello sviluppo di giochi identificando meccaniche di gioco raramente esercitate e casi limite nel codice di simulazione della fisica del gioco

Come funziona

Come funziona

1

Strumentare il codice sorgente con sonde che registrano eventi di esecuzione. Ottenere la suite di test e il sistema in prova (SUT).

2

Compilare o trasformare il codice per includere la strumentazione che traccia quali istruzioni, rami o percorsi vengono eseguiti durante le esecuzioni di test.

3

Eseguire la suite di test sul codice strumentato, registrando quali elementi del programma sono coperti. Raccogliere tracce di esecuzione e dati di copertura.

4

Aggregare metriche di copertura a più livelli: copertura delle righe, copertura dei rami, copertura dei percorsi, copertura dei metodi. Calcolare le percentuali di copertura e identificare le regioni di codice non toccate.

5

Visualizzare il codice non coperto, analizzare le lacune di copertura e generare raccomandazioni per casi di test aggiuntivi mirati alle lacune di copertura.

Errori comuni

  • Perseguire obiettivi di percentuale di copertura (ad es., 80%) senza attenzione alla qualità dei test; i test orientati alla copertura sono spesso deboli
  • Ignorare che raggiungere il 100% di copertura è spesso infattibile e non conveniente in sistemi di grandi dimensioni
  • Trattare la copertura come una garanzia di correttezza; un'elevata copertura e test superati non garantiscono l'assenza di difetti logici
  • Utilizzare la copertura da sola per valutare la competenza degli sviluppatori; la pressione per raggiungere la copertura porta al 'gaming' (test banali che non aggiungono valore)

Domande frequenti

Qual è la differenza tra copertura di istruzione, di ramo e di percorso?

La copertura delle istruzioni misura se ogni riga viene eseguita; ogni istruzione visitata almeno una volta. La copertura dei rami richiede che ogni condizionale (if, switch) valuti sia vero che falso. La copertura dei percorsi assicura che tutte le sequenze di esecuzione distinte vengano eseguite. La copertura dei percorsi è la più forte ma spesso infattibile; la copertura dei rami offre un equilibrio pratico.

Il 100% di copertura è un obiettivo realistico o desiderabile?

Raggiungere il 100% di copertura è raramente conveniente. I sistemi raggiungono tipicamente il 75-90% di copertura; il 10-25% finale coinvolge spesso gestori di errori raramente eseguiti, codice legacy o integrazioni di terze parti. Si applicano rendimenti decrescenti: lo sforzo per raggiungere il 100% supera spesso il beneficio marginale. Puntare al 75-85% di copertura per la maggior parte dei progetti; 90%+ per sistemi critici per la sicurezza.

Come può un'elevata copertura coesistere con alti tassi di difetti in alcuni progetti?

La copertura misura l'ampiezza (percorsi di codice eseguiti), non la profondità (qualità delle asserzioni). Un test può coprire una riga senza asserire l'esito corretto. Un'elevata copertura con asserzioni deboli crea una falsa sicurezza. Concentrarsi sulla progettazione significativa dei test insieme agli obiettivi di copertura.

Come affronto le lacune di copertura in librerie di terze parti o codice generato?

Escludere codice di terze parti e generato dalle metriche di copertura utilizzando la configurazione (ad es., regole di esclusione JaCoCo). Concentrarsi sul codice dell'applicazione che si controlla. Alcuni team impostano soglie di copertura separate per il codice generato (ad es., 40%) rispetto alla logica scritta a mano (ad es., 80%) per riflettere aspettative realistiche.

Metodi correlati

Fonti

  1. Zhu, H., Hall, P. A. V., & May, J. H. R. (1997). Software unit test coverage and adequacy. ACM Computing Surveys, 29(4), 366–427.

    Apri il riferimento DOI
    Copiato.
  2. Frankl, P. G., & Weiss, S. N. (1988). An experimental comparison of the effectiveness of branch testing and data flow testing. IEEE Transactions on Software Engineering, 14(12), 1763–1773.

    Apri il riferimento della pubblicazione
    Copiato.
  3. Corbet, J. (2008). Code coverage for the Linux kernel. Linux Weekly News article.

    Apri il riferimento della pubblicazione
    Copiato.