Tutorial sulla copertura del codice: test di rami, dichiarazioni e decisioni

Cos'è la copertura del codice?

La copertura del codice è una misura che descrive il grado in cui il codice sorgente del programma è stato testato. È una forma di test white box che individua le aree del programma non esercitate da un set di casi di test. Crea anche alcuni casi di test per aumentare la copertura e determinare una misura quantitativa della copertura del codice.

Nella maggior parte dei casi, il sistema di copertura del codice raccoglie informazioni sul programma in esecuzione. Inoltre, lo combina con le informazioni sul codice sorgente per generare un report sulla copertura del codice della suite di test.

Perché utilizzare i test di copertura del codice?

Ecco alcuni motivi principali per utilizzare la copertura del codice:

• Ti aiuta a misurare l'efficienza dell'implementazione dei test
• Offre una misurazione quantitativa.
• Definisce il grado in cui il codice sorgente è stato testato.

Metodi di copertura del codice

Di seguito sono riportati i principali metodi di copertura del codice

• Copertura della dichiarazione
• Copertura della decisione
• Copertura delle filiali
• Toggle Copertura
• Copertura FSM

Dichiarazione di copertura

Dichiarazione di copertura è una tecnica di test white box in cui tutte le istruzioni eseguibili nel codice sorgente vengono eseguite almeno una volta. Viene utilizzata per calcolare il numero di istruzioni nel codice sorgente che sono state eseguite. Lo scopo principale di Statement Coverage è quello di coprire tutti i possibili percorsi, linee e istruzioni nel codice sorgente.

La copertura delle istruzioni viene utilizzata per derivare uno scenario in base alla struttura del codice sotto test.

In Bianco Box Collaudo, il tester si concentra su come funziona il software. In altre parole, il tester si concentrerà sul funzionamento interno del codice sorgente relativo ai grafici di flusso di controllo o ai diagrammi di flusso.

Generalmente in qualsiasi software, se guardiamo il codice sorgente, ci sarà un'ampia varietà di elementi come operatori, funzioni, cicli, gestori eccezionali, ecc. In base all'input del programma, alcune istruzioni del codice potrebbero non essere eseguite . L'obiettivo della copertura delle istruzioni è coprire tutti i possibili percorsi, righe e istruzioni nel codice.

Capiamolo con un esempio, come calcolare la copertura dell'estratto conto.

Scenario per calcolare la copertura della dichiarazione per un determinato codice sorgente. Qui stiamo prendendo due diversi scenari per verificare la percentuale di copertura dell'estratto conto per ciascuno scenario.

Codice sorgente:

Prints (int a, int b) {                       ------------  Printsum is a function 
    int result = a+ b; 
    If (result> 0)
    	Print ("Positive", result)
    Else
    	Print ("Negative", result)
    }                                        -----------   End of the source code 

Scenario 1:

Se A = 3, B = 9

Le istruzioni contrassegnate in giallo sono quelle che vengono eseguite secondo lo scenario

Numero di istruzioni eseguite = 5, Numero totale di istruzioni = 7

Copertura dell'estratto conto: 5/7 = 71%

Allo stesso modo vedremo lo scenario 2,

Scenario 2:

Se A = -3, B = -9

Le istruzioni contrassegnate in giallo sono quelle che vengono eseguite secondo lo scenario.

Numero di istruzioni eseguite = 6

Numero totale di affermazioni = 7

Copertura dell'estratto conto: 6/7 = 85%

Ma nel complesso, se vedi, tutte le affermazioni rientrano in entrambi gli scenari. Possiamo quindi concludere che la copertura complessiva della dichiarazione è del 100%.

Cosa è coperto dalla copertura assicurativa?

1. Dichiarazioni non utilizzate
2. Codice morto
3. Rami inutilizzati
4. Dichiarazioni mancanti

Test di copertura delle decisioni

Copertura della decisione è una tecnica di test white box che riporta i risultati veri o falsi di ogni espressione booleana del codice sorgente. L'obiettivo del test di copertura delle decisioni è di coprire e convalidare tutto il codice sorgente accessibile controllando e assicurando che ogni ramo di ogni possibile punto di decisione venga eseguito almeno una volta.

In questo tipo di copertura, le espressioni possono diventare complesse, rendendo difficile raggiungere una copertura del 100%. Ecco perché vengono utilizzati vari metodi per segnalare questa metrica. Questi metodi danno priorità alle combinazioni più critiche. Sebbene sia simile alla copertura delle decisioni, fornisce una maggiore sensibilità al flusso di controllo.

Esempio di copertura delle decisioni

Considerare il seguente codice:

Demo(int a) {                       
     If (a> 5)
    	a=a*3
     Print (a)
    }

Scenario 1:

Il valore di a è 2

Verrà eseguito il codice evidenziato in giallo. Qui viene verificato l'esito “No” della decisione Se (a>5).

Copertura della decisione = 50%

Scenario 2:

Il valore di a è 6

Verrà eseguito il codice evidenziato in giallo. Qui viene verificato l'esito "Sì" della decisione Se (a>5).

Copertura della decisione = 50%

Test Case	Valore di A	Uscita	Copertura della decisione
1	2	2	50%
2	6	18	50%

Test di copertura delle filiali

Copertura delle filiali è un metodo di test white box in cui ogni risultato di un modulo di codice (istruzione o ciclo) viene testato. Lo scopo della copertura dei rami è di garantire che ogni condizione di decisione da ogni ramo venga eseguita almeno una volta. Aiuta a misurare frazioni di segmenti di codice indipendenti e a scoprire le sezioni che non hanno rami.

Ad esempio, se i risultati sono binari, è necessario verificare sia i risultati Vero che quelli Falsi.

La formula per calcolare la copertura delle filiali:

Esempio di copertura delle filiali

Per apprendere la copertura delle filiali, consideriamo lo stesso esempio utilizzato in precedenza

Considerare il seguente codice:

Demo(int a) {                       
     If (a> 5)
    	a=a*3
     Print (a)
    }                                       

Branch Coverage prenderà in considerazione anche il ramo incondizionato

Test Case	Valore di A	Uscita	Copertura della decisione	Copertura delle filiali
1	2	2	50%	33%
2	6	18	50%	67%

Vantaggi della copertura delle filiali:

Il test di copertura delle filiali offre i seguenti vantaggi:

• Permette di validare tutti i rami del codice
• Ti aiuta a garantire che nessuna ramificazione porti ad anomalie nel funzionamento del programma
• Il metodo di copertura delle filiali rimuove i problemi che si verificano a causa del test di copertura delle dichiarazioni
• Ti permette di trovare quelle aree che non sono testate con altri metodi di test
• Ti consente di trovare una misura quantitativa della copertura del codice
• La copertura dei rami ignora i rami all'interno delle espressioni booleane

Test di copertura delle condizioni

Copertura delle condizioni o la copertura dell'espressione è un metodo di test utilizzato per testare e valutare le variabili o le sottoespressioni nell'istruzione condizionale. L'obiettivo della copertura delle condizioni è verificare i risultati individuali per ciascuna condizione logica. La copertura delle condizioni offre una migliore sensibilità al flusso di controllo rispetto alla copertura delle decisioni. In questa trattazione vengono prese in considerazione solo le espressioni con operandi logici.

Ad esempio, se un'espressione ha operazioni booleane come AND, OR, XOR, che indica le possibilità totali.

La copertura delle condizioni non fornisce una garanzia sulla copertura completa della decisione.

La formula per calcolare la copertura delle condizioni:

Esempio:

Per l'espressione sopra abbiamo 4 possibili combinazioni

• TT
• FF
• TF
• FT

Considerare il seguente input

X = 3 Y = 4	(X	TRUE	La copertura delle condizioni è ¼ = 25%
A = 3 B = 4	(a>b)	FALSO

Copertura della macchina a stati finiti

La copertura della macchina a stati finiti è sicuramente il tipo più complesso di metodo di copertura del codice. Questo perché lavora sul comportamento del design. In questo metodo di copertura, devi cercare quanti stati specifici del tempo vengono visitati, transitati. Controlla anche quante sequenze sono incluse in una macchina a stati finiti.

Quale tipo di Code Coverage scegliere

Questa è sicuramente la risposta più difficile da dare. Per selezionare un metodo di copertura, il tester deve verificare che

• il codice in prova presenta uno o più difetti non ancora scoperti
• costo dell’eventuale sanzione
• costo della perdita di reputazione
• costo della mancata vendita, ecc.

Maggiore è la probabilità che i difetti causino costosi guasti alla produzione, più severo sarà il livello di copertura da scegliere.

Copertura del codice e copertura funzionale

Copertura del codice	Copertura funzionale
La copertura del codice ti dice quanto bene il codice sorgente è stato esercitato dal tuo banco di prova.	La copertura funzionale misura quanto bene la funzionalità del progetto è stata coperta dal banco di prova.
Non utilizzare mai una specifica di progettazione	Utilizzare le specifiche di progettazione
Fatto dagli sviluppatori	Fatto dai tester

Strumenti di copertura del codice

Di seguito è riportato un elenco di strumenti importanti per la copertura del codice:

Nome strumento	Descrizione
Cobertura	È uno strumento di copertura del codice open source. Misura la copertura del test strumentando una base di codice e analizza quali righe di codice vengono eseguite e quali non vengono eseguite durante l'esecuzione della suite di test.
Trifoglio	Clover riduce inoltre i tempi di test eseguendo solo i test che coprono il codice dell'applicazione che è stato modificato rispetto alla build precedente.
Partner di sviluppo	DevPartner consente agli sviluppatori di analizzare Java codice per la qualità e la complessità del codice.
Emma	EMMA supporta la copertura di classi, metodi, linee e blocchi base, file di origine aggregati, livelli di classi e metodi.
Kalistick	Kalistick è un'applicazione di terze parti che analizza i codici con diverse prospettive.
CoView e CoAnt	Il software di codifica è uno strumento di copertura del codice per metriche, creazione di oggetti fittizi, testabilità del codice, copertura di percorsi e rami, ecc.
Bullseye per C++	BulseyeCoverage è uno strumento di copertura del codice per C++ e C.
Sonar	Sonar è uno strumento di copertura del codice aperto che ti aiuta a gestire la qualità del codice.

Vantaggi e svantaggi dell'utilizzo del Code Coverage

Vantaggi della copertura del codice	Svantaggi della copertura del codice
Utile per valutare una misura quantitativa della copertura del codice	Anche quando una funzionalità specifica non è implementata nella progettazione, la copertura del codice riporta comunque una copertura del 100%.
Ti consente di creare casi di test aggiuntivi per aumentare la copertura	Non è possibile determinare se abbiamo testato tutti i possibili valori di una caratteristica con l'aiuto della copertura del codice
Permette di trovare le aree di un programma che non vengono esercitate da una serie di casi di test	Inoltre, la copertura del codice non dice quanto e quanto bene hai coperto la tua logica
	Nel caso in cui la funzione specificata non sia stata implementata o non sia inclusa nelle specifiche, le tecniche basate sulla struttura non sono in grado di individuare il problema.

Sintesi

• La copertura del codice è una misura che descrive il grado di test del codice sorgente del programma
• Ti aiuta a misurare l'efficienza dell'implementazione dei test
• Cinque metodi di Code Coverage sono 1.) Statement Coverage 2.) Condition Coverage 3) Branch Coverage 4) Toggle Copertura 5) Copertura FSM
• La copertura delle istruzioni implica l'esecuzione di tutte le istruzioni eseguibili nel codice sorgente almeno una volta
• La copertura decisionale riporta i risultati veri o falsi di ciascuna espressione booleana
• Nella copertura del ramo, viene testato ogni risultato di un modulo di codice
• Il condizionale rivelerà come vengono valutate le variabili o le sottoespressioni nell'istruzione condizionale
• La copertura della macchina a stati finiti è sicuramente il tipo più complesso di metodo di copertura del codice
• Per selezionare un metodo di copertura, il tester deve verificare il costo della potenziale sanzione, perdita di reputazione, mancata vendita, ecc.
• La copertura del codice indica quanto bene il codice sorgente è stato utilizzato dal banco di prova, mentre la copertura funzionale misura quanto bene è stata coperta la funzionalità del progetto
• Cobertura, JTest, Clover, Emma, ​​Kalistick sono alcuni importanti strumenti di copertura del codice
• Code Coverage ti consente di creare casi di test aggiuntivi per aumentare la copertura
• La Code Coverage non ti aiuta a determinare se abbiamo testato tutti i possibili valori di una funzionalità