Che cos'è la copertura del codice e come lo si misura?

Che cos'è la copertura del codice e come lo si misura?

Mi è stata posta questa domanda per quanto riguarda la copertura del codice di test automatizzato. Sembra che, al di fuori degli strumenti automatizzati, sia più arte che scienza. Esistono esempi reali di come utilizzare la copertura del codice?

La copertura del codice è una misura di quante linee / blocchi / archi del tuo codice vengono eseguiti mentre i test automatici sono in esecuzione.

La copertura del codice viene raccolta utilizzando uno strumento specializzato per strumentare i binari per aggiungere chiamate di traccia ed eseguire una serie completa di test automatizzati sul prodotto strumentato. Un buon strumento ti fornirà non solo la percentuale del codice eseguito, ma ti consentirà anche di analizzare i dati e vedere esattamente quali righe di codice sono state eseguite durante un determinato test.

Il nostro team utilizza Magellan , un set interno di strumenti per la copertura del codice. Se sei un negozio .NET, Visual Studio ha strumenti integrati per raccogliere la copertura del codice. Puoi anche creare alcuni strumenti personalizzati, come descritto in questo articolo .

Se sei un negozio C ++, Intel ha alcuni strumenti che funzionano per Windows e Linux, anche se non li ho usati. Ho anche sentito che c'è lo strumento gcov per GCC, ma non ne so nulla e non posso darti un link.

Quanto a come lo usiamo - la copertura del codice è uno dei nostri criteri di uscita per ogni pietra miliare. Abbiamo in realtà tre metriche di copertura del codice: copertura da test unitari (dal team di sviluppo), test di scenario (dal team di test) e copertura combinata.

A proposito, mentre la copertura del codice è una buona metrica di quanti test stai facendo, non è necessariamente una buona metrica di quanto bene stai testando il tuo prodotto. Esistono altre metriche da utilizzare insieme alla copertura del codice per garantire la qualità.

La copertura del codice fondamentalmente verifica che la quantità di codice coperta sia coperta dai test. Quindi, se hai una copertura del codice del 90%, significa che c'è un 10% di codice che non è coperto dai test. So che potresti pensare che il 90% del codice sia coperto, ma devi guardare da una prospettiva diversa. Cosa ti impedisce di ottenere una copertura del codice del 100%?

Un buon esempio sarà questo:

if(customer.IsOldCustomer()) 
{
}
else 
{
}

Ora, nel codice sopra ci sono due percorsi / rami. Se si colpisce sempre il ramo "SÌ", non si copre l'altra parte e verrà visualizzato nei risultati della copertura del codice. Questo va bene perché ora sai che ciò che non è coperto e puoi scrivere un test per coprire l'altra parte. Se non c'era copertura del codice, allora sei semplicemente seduto su una bomba a tempo per esplodere.

NCover è un buon strumento per misurare la copertura del codice.

Ricorda, avere una "copertura del codice al 100%" non significa che tutto sia testato completamente - mentre significa che ogni riga di codice è testata, non significa che siano testati in ogni situazione (comune).

Vorrei utilizzare la copertura del codice per evidenziare parti di codice per le quali probabilmente dovrei scrivere dei test. Ad esempio, se qualunque strumento di copertura del codice mostra myImportantFunction () non viene eseguito durante l'esecuzione dei miei test unitari attuali, probabilmente dovrebbero essere migliorati.

Fondamentalmente, la copertura del codice al 100% non significa che il tuo codice sia perfetto. Usalo come guida per scrivere test più completi (unitari).

Completando alcuni punti a molte delle risposte precedenti:

Copertura del codice significa quanto bene il tuo set di test copre il tuo codice sorgente. cioè fino a che punto il codice sorgente è coperto dall'insieme di casi di test.

Come menzionato nelle risposte precedenti, ci sono vari criteri di copertura, come percorsi, condizioni, funzioni, dichiarazioni, ecc. Ma criteri aggiuntivi da coprire sono

1. Copertura delle condizioni: tutte le espressioni booleane devono essere valutate come vere e false.
2. Copertura delle decisioni: non solo espressioni booleane da valutare una volta per vero e falso, ma per coprire tutto il corpo if-elseif-else successivo.
3. Copertura del circuito: significa che è stato eseguito ogni ciclo possibile una volta, più di una volta e zero volte. Inoltre, se abbiamo ipotesi sul limite massimo, quindi, se possibile, testare i tempi limite massimi e uno oltre i tempi limite massimi.
4. Copertura di entrata e uscita: verifica tutte le chiamate possibili e il relativo valore di ritorno.
5. Copertura del valore dei parametri (PVC). Per verificare se vengono testati tutti i valori possibili per un parametro. Ad esempio, una stringa può essere una qualsiasi di queste comunemente: a) null, b) vuota, c) spazio bianco (spazio, tabulazioni, nuova riga), d) stringa valida, e) stringa non valida, f) stringa a byte singolo, g ) stringa a doppio byte. La mancata verifica di ogni possibile valore di parametro può lasciare un bug. Testare solo uno di questi potrebbe comportare una copertura del codice del 100% poiché ogni riga è coperta, ma poiché viene testata solo una delle sette opzioni, significa solo una copertura del 14,2% del valore del parametro.
6. Copertura dell'ereditarietà: in caso di origine orientata agli oggetti, quando si restituisce un oggetto derivato riferito dalla classe base, la copertura da valutare, se viene restituito un oggetto fratello, deve essere testata.

Nota: l'analisi del codice statico rileverà se ci sono codici non raggiungibili o codici sospesi, ovvero codici non coperti da altre chiamate di funzioni. E anche altra copertura statica. Anche se l'analisi del codice statico segnala che il codice al 100% è coperto, non fornisce rapporti sul set di test se viene testata tutta la copertura del codice possibile.

La copertura del codice è stata spiegata bene nelle risposte precedenti. Quindi questa è più una risposta alla seconda parte della domanda.

Abbiamo usato tre strumenti per determinare la copertura del codice.

1. JTest - uno strumento proprietario costruito su JUnit. (Genera anche unit test.)
2. Cobertura - uno strumento di copertura del codice open source che può essere facilmente associato ai test JUnit per generare report.
3. Emma - un'altra - questa che abbiamo usato per uno scopo leggermente diverso dai test unitari. È stato utilizzato per generare report di copertura quando gli utenti finali accedono all'applicazione Web. Questo in combinazione con strumenti di test web (esempio: Canoo) può darti rapporti di copertura molto utili che ti dicono quanto codice è coperto durante l'uso tipico dell'utente finale.

Usiamo questi strumenti per

• Verifica che gli sviluppatori abbiano scritto buoni test unitari
• Accertarsi che tutto il codice venga attraversato durante i test in black box

La copertura del codice è semplicemente una misura del codice che viene testato. Esistono diversi criteri di copertura che possono essere misurati, ma in genere sono i vari percorsi, condizioni, funzioni e dichiarazioni all'interno di un programma a determinare la copertura totale. La metrica di copertura del codice è solo una percentuale di test che eseguono ciascuno di questi criteri di copertura.

Per quanto riguarda il monitoraggio della copertura dei test delle unità sui miei progetti, utilizzo gli strumenti di analisi del codice statico per tenere traccia.

Per Perl c'è l'eccellente modulo Develop :: Cover che uso regolarmente sui miei moduli.

Se la compilazione e l'installazione sono gestite da Module :: Build, puoi semplicemente eseguire ./Build testcoverper ottenere un bel sito HTML che ti dice la copertura per sottotitolo, linea e condizione, con bei colori che rendono facile vedere quale percorso del codice non è stato coperto.

Nelle risposte precedenti la copertura del codice è stata spiegata bene. Sto solo aggiungendo alcune conoscenze relative agli strumenti se stai lavorando iOSe alle OSXpiattaforme, Xcode offre la possibilità di testare e monitorare la copertura del codice.

Link di riferimento:

https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/07-code_coverage.html

https://medium.com/zendesk-engineering/code-coverage-and-xcode-6b2fb8756a51

Entrambi sono collegamenti utili per l'apprendimento e l'esplorazione della copertura del codice con Xcode.

Per PHP dovresti dare un'occhiata al Github di Sebastian Bergmann

Fornisce funzionalità di raccolta, elaborazione e rendering per le informazioni sulla copertura del codice PHP.

https://github.com/sebastianbergmann/php-code-coverage