code coverage tutorial
Questo tutorial completo spiega cos'è la copertura del codice nel test del software, i suoi tipi, vantaggi e svantaggi:
L'obiettivo finale di qualsiasi azienda di sviluppo software è sviluppare software di buona qualità. Per raggiungere questo obiettivo, il software deve essere accuratamente testato.
Il test è quindi parte integrante dello sviluppo di un'applicazione software. Quindi è essenziale che il software sviluppato sia rivisto dallo sviluppatore (che viene fatto durante la fase di test unitario) e quindi passato al team QC per essere testato a fondo per garantire che abbia bug minimi o nulli.
Il software viene testato in unità prima di essere rilasciato al team di test effettivo per il test. Poiché questo test implica il test a livello di codice, viene eseguito dallo sviluppatore. Questa operazione viene eseguita per garantire che ogni parte del codice in fase di test funzioni come previsto.
Qui, piccoli pezzi di codice che sono stati sviluppati vengono testati isolatamente per assicurarne la correttezza. Ma la domanda che spesso incombe nella mente di uno sviluppatore è quanto di unit test dovrebbe essere fatto e la risposta a questo sta nella copertura del codice.
Questo tutorial ti fornirà una conoscenza approfondita di cos'è la copertura del codice e perché ne abbiamo bisogno. Sapresti come differisce dalla copertura del test.
Daremo anche uno sguardo agli strumenti e alle metodologie utilizzati per la copertura del codice e verso la fine di questo tutorial, vedremo i vantaggi insieme ai suoi svantaggi. Alcuni dei miti associati alla copertura del codice sarebbero anche coperti qui.
Cosa imparerai:
Che cos'è la copertura del codice
Questa è un'importante metrica di unit test. È utile per conoscere l'efficacia dei test unitari. È una misura che indica quale percentuale di codice sorgente verrebbe eseguita durante il test.
In parole povere, la misura in cui il codice sorgente di un programma software o di un'applicazione verrà eseguito durante il test è ciò che viene definito Copertura del codice.
Se i test eseguono l'intero pezzo di codice inclusi tutti i rami, le condizioni o i loop, allora diremmo che c'è una copertura completa di tutti i possibili scenari e quindi la Copertura del codice è del 100%. Per capirlo ancora meglio, facciamo un esempio.
Di seguito è riportato un semplice codice che viene utilizzato per aggiungere due numeri e visualizzare il risultato in base al valore del risultato.
Input a, b Let c = a + b If c <10, print c Else, print ‘Sorry’
Il programma di cui sopra accetta due input, ovvero 'a' e 'b'. La somma di entrambi è memorizzata nella variabile c. Se il valore di c è inferiore a 10, viene stampato il valore di 'c', altrimenti viene stampato 'Sorry'.
Ora, se abbiamo alcuni test per convalidare il programma sopra con i valori di a & b in modo tale che la somma sia sempre inferiore a 10, la parte else del codice non viene mai eseguita. In uno scenario del genere, diremmo che la copertura non è completa.
Questo era solo un piccolo esempio per chiarire il significato di Code Coverage. Man mano che esploriamo di più, acquisirai maggiore chiarezza su di esso.
Perché abbiamo bisogno della copertura del codice
[Immagine fonte ]
Vari motivi rendono essenziale la copertura del codice e alcuni di questi sono elencati di seguito:
quale delle seguenti non è una condizione che descrive uno scenario di test?
- Aiuta ad accertare che il software abbia bug minori rispetto al software che non ha una buona copertura del codice.
- Aiutando a migliorare la qualità del codice, aiuta indirettamente a fornire un software di 'qualità' migliore.
- È una misura che può essere utilizzata per conoscere l'efficacia del test (efficacia degli unit test scritti per testare il codice).
- Aiuta a identificare quelle parti del codice sorgente che non verrebbero testate.
- Aiuta a determinare se il test corrente (test unitario) è sufficiente o meno e se sono necessari anche altri test.
Copertura del codice rispetto alla copertura del test
Per comprendere la differenza tra copertura del codice e copertura del test, capiamo prima il significato di copertura del test.
Copertura del test
È una misura di quante parti del test previsto sono state coperte durante il test di un software. Di 'Test previsto' intendiamo l'insieme completo di casi di test che vengono scritti per essere eseguiti per testare un determinato software.
Supponiamo che per testare un software sia stato scritto un set di 500 casi di test totali. Ora, come parte dell'attività di test, sono stati eseguiti solo 300 casi di test. Supponiamo che ciò sia dovuto alla mancanza di tempo. In questo caso, la seguente sarebbe la copertura del test.
Copertura del test = (casi di test eseguiti / casi di test totali) * 100
= (300/500) * 100
= 60%
Confrontiamo questo con ciò che è la copertura del codice.
Copertura del codice
È una misura che mostra la misura in cui un codice sorgente di un'applicazione viene eseguito durante il test del codice. Quindi mostra il grado in cui un codice sorgente verrebbe testato.
Supponiamo di testare un'applicazione con 500 righe di codice, solo 400 righe di codice vengono eseguite dai test. Supponiamo che ciò sia dovuto al fatto che un certo ciclo / condizione non viene eseguito. In questo caso, il seguente sarebbe la copertura del codice.
dove posso guardare anime gratis online
Copertura codice = (numero di righe di codice eseguite / numero totale di righe di codice) * 100
= (400/500) * 100
= 80%
Di seguito sono elencate le differenze tra Copertura del codice e Copertura del test:
Copertura del test | Copertura del codice |
---|---|
È una misura di quanta parte del test previsto è stato coperto durante il test di un software. | È una misura che mostra la misura in cui un codice sorgente di un'applicazione viene eseguito durante il test del codice. |
La copertura del test può essere calcolata utilizzando la formula seguente: Copertura del test = (casi di test eseguiti / casi di test totali) * 100 | La copertura del codice può essere calcolata utilizzando la formula seguente: Copertura codice = (numero di righe di codice eseguite / numero totale di righe di codice) * 100 |
Metodologie
Qui discuteremo i vari metodi che sono / possono essere usati per misurare la Copertura del Codice.
Per comprendere queste metodologie, diamo un'occhiata allo snippet di codice seguente:
Add (int a, int b) { If (b > a) { b = b - a Print b } If (a > b) { b = a – b Print b } Else Print ‘0’ }
Copertura della dichiarazione
Questa metodologia è una misura che indica se tutte le possibili istruzioni eseguibili di codice nel codice sorgente sono state eseguite almeno una volta. È un metodo per garantire che ogni riga del codice sorgente sia coperta almeno una volta dai test.
Potrebbe sembrare semplice, ma è necessario prestare attenzione durante la misurazione della copertura della dichiarazione. Il motivo è che in un codice sorgente potrebbe esserci una certa condizione che potrebbe non essere eseguita a seconda dei valori di input.
Ciò significherebbe che tutte le righe di codice non sarebbero state trattate in testing. Pertanto, potremmo dover utilizzare diversi set di valori di input per coprire tutte queste condizioni nel codice sorgente.
Per esempio, nel codice sorgente di cui sopra se i valori di input sono presi come 2 e 3, la parte 'Else' del codice non verrebbe eseguita. Tuttavia, se i valori di input sono di tipo 3 e 2, la parte 'If' del codice non verrebbe eseguita.
Ciò significa che con entrambi i set di valori della nostra copertura delle dichiarazioni non sarebbe del 100%. In tal caso, potremmo dover eseguire i test con tutti e tre i [(2, 3), (3, 2), (0, 0)] set di valori per garantire il 100% di copertura dell'istruzione.
Copertura delle funzioni
Come suggerisce il nome, questa metodologia misura la misura in cui le funzioni presenti nel codice sorgente vengono coperte durante il test. Tutte le funzioni presenti nel codice sorgente vengono testate durante l'esecuzione del test. Ancora una volta, è necessario assicurarsi di testare queste funzioni per valori variabili in modo che la funzione venga testata a fondo.
In un codice sorgente possono esserci più funzioni e, a seconda dei valori di input utilizzati, una funzione può o non può essere chiamata. Pertanto, lo scopo della copertura delle funzioni è garantire che ogni funzione sia richiesta.
Per esempio, nel codice sorgente sopra, se i nostri test chiamano la funzione 'Aggiungi' anche una sola volta, allora la chiameremmo come copertura completa della funzione.
Copertura delle condizioni
In un codice sorgente, ovunque sia presente una condizione, il risultato sarebbe un valore booleano true o false. La copertura delle condizioni mira a stabilire se i test coprono entrambi i valori, ovvero vero, falso.
Nel codice sorgente, quando ogni condizione che si verifica viene valutata sia per lo stato vero che per quello falso, si dice che la copertura delle condizioni per il codice sia completa.
Per esempio, nel codice precedente se vengono utilizzati i set di valori (2, 3) e (4, 2), la copertura delle condizioni sarà del 100%. Quando viene utilizzato il set di dati (2, 3), (b> a) restituisce true e (a> b) restituisce false. Allo stesso modo, quando viene utilizzato il set di dati (4, 2), (b> a) restituisce falso e (a> b) restituisce vero.
Quindi entrambe le condizioni hanno entrambi i valori, cioè vero e falso coperto. Quindi la copertura delle condizioni sarebbe del 100%.
Copertura delle filiali
Questa metodologia mira a garantire che ogni ramo che appare in ogni struttura condizionale venga eseguito nel codice sorgente. Ad esempio, nel codice precedente, tutte le istruzioni 'If' e qualsiasi istruzione 'Else' di accompagnamento dovrebbero essere tutte coperte dal test per una copertura del ramo del 100%.
Per esempio, nel codice precedente se vengono utilizzati i set di valori (2, 3), (4, 2), (1, 1), la copertura del ramo sarà del 100%. Quando viene utilizzato il set di dati (2, 3), allora (b> a) e il primo ramo 'If' viene eseguito. Allo stesso modo, quando viene utilizzato il set di dati (4, 2), (a> b) restituisce true e viene eseguito il secondo ramo 'If'.
Quindi con il set di dati (1, 1) il ramo 'Else' restituisce true e viene eseguito. In tal modo, garantendo il 100% di copertura delle filiali.
Copertura delle filiali Vs Copertura delle condizioni
La copertura delle filiali viene spesso confusa con la copertura delle condizioni, tuttavia le due sono diverse.
Capiamo questo con un semplice esempio.
If (a >0) & (b >0) Then Print “Hello” Else Print “Bye”
Scriviamo il set di dati necessari per il completamento Copertura delle filiali:
(1, 1) - In questo caso, 'a' e 'b' sono entrambi veri, quindi la condizione If viene eseguita.
(1, 0) - In questo caso, 'a' è vero e 'b' sarebbe falso, quindi viene eseguita la parte Else del codice.
Come sappiamo, lo scopo di Branch Coverage è quello di far eseguire ogni ramo almeno una volta e questo scopo viene raggiunto.
Copertura delle condizioni:
(1, 0) - In questo caso, 'a' è vero e 'b' sarebbe falso.
(0, 1) - In questo caso, 'a' è falso e 'b' sarebbe vero.
Lo scopo della copertura delle condizioni è quello di ottenere ogni condizione vero e falso per ogni condizione eseguita e questo scopo viene raggiunto qui.
Hai notato che l'altra parte non viene eseguita nella copertura delle condizioni? È qui che la copertura delle condizioni differisce dalla copertura delle filiali.
Strumenti per la copertura del codice
Per misurare la copertura del codice di qualsiasi software, sul mercato sono disponibili diversi strumenti.
Di seguito sono elencati alcuni degli strumenti per il tuo riferimento:
- Parasoft JTest
- Testwell CTC ++
- Copertura
- JaCoCo
- CodeCover
- BullseyeCoverage
- EMMA
- OpenCover
- NCover
- Squish COCO
- CoverageMeter
- GCT
- TCAT C / C ++
- Gretel
- JCov
Lettura consigliata => Strumenti di copertura del codice
Il collegamento sopra includerà le seguenti informazioni su questi strumenti:
- Caratteristiche principali
- Tipo di licenza
- URL ufficiale
- Pro e contro
- Ultima versione
Benefici
Come visto sopra, è una metrica di test molto utile per i seguenti motivi:
- Aiuta a identificare quelle aree in un codice sorgente che rimarrebbero non testate / scoperte dai test.
- È utile per identificare il codice usato / morto migliorando così la qualità del codice.
- L'efficacia degli unit test può essere conosciuta con l'aiuto di Code Coverage.
- Il software di qualità migliore può essere fornito utilizzando queste metriche.
Inconvenienti
- Cercare di puntare a una copertura del codice al 100% a volte causa una mancanza di robustezza dei test con conseguente perdita di acquisizione degli scenari soggetti a difetti.
- A differenza della percezione comune, non può garantire se il software progettato soddisfa tutti i requisiti.
Miti contro fatti
Mito | Fatto |
---|---|
Avere una copertura del codice del 100% garantisce che il software non abbia bug. | No, la copertura del codice al 100% non può garantire un software privo di bug. Una buona copertura del codice unita a buoni sforzi da parte del team QC può garantire un software con bug minimi o nulli. |
Avere una copertura del codice del 100% significa che il codice scritto è perfetto. | No, in effetti, se i requisiti importanti non sono stati acquisiti dal codice in primo luogo, il codice non può essere definito perfetto nonostante la copertura del codice sia del 100%. |
La copertura del codice misura l'efficacia dei test eseguiti su un prodotto software. | No, la copertura del codice è solo una misura utilizzata per testare l'efficacia degli unit test, ovvero i test eseguiti solo sul codice sorgente di un software. |
Domande frequenti
D # 1) Che cos'è una copertura del codice accettabile?
Risposta: Il raggiungimento del 100% di copertura del codice non dovrebbe essere l'obiettivo durante il test dell'unità del codice software. Ma perchè no? Per capire il motivo potrebbe essere necessario immergersi un po 'più a fondo per capire il significato sottostante.
Quando miriamo a una copertura del 100%, accade più spesso che tutta l'attenzione nella progettazione dei test vada a garantire che ogni istruzione, loop, ramo o condizione venga testata. Quindi arriviamo a mettere troppi sforzi che potrebbero non valere la pena considerando il tempo speso.
Inoltre, concentrarsi su una copertura elevata si traduce anche nel perdere gli scenari importanti che potrebbero presentare i difetti perché tutto ciò a cui miriamo è garantire che ogni riga di codice venga testata.
Concentrarsi su un'elevata copertura del codice non è sempre così importante e non può nemmeno essere un numero fisso su cui mirare per testare codici diversi. Tuttavia, in generale, una copertura del 75% - 80% dovrebbe essere un numero ideale.
Durante il test del nostro codice, l'obiettivo principale dovrebbe essere quello di garantire la copertura degli scenari critici e potenzialmente soggetti a errori. Se questi vengono persi, nonostante abbiano una copertura del codice del 100%, i nostri test avrebbero semplicemente una scarsa efficacia.
Q # 2) Come posso controllare la copertura del mio codice?
come visualizzare i file eps in Windows
Risposta: Per testare la percentuale di copertura del codice che potresti aver ottenuto dai test progettati per testare il codice, abbiamo diversi strumenti sul mercato. A seconda del linguaggio di programmazione che si sta utilizzando, abbiamo vari strumenti.
Alcuni di loro sono elencati di seguito:
- Giava - Copertura, JaCoCo
- Javascript - Blanket.js, Istanbul
- Pitone - Coverage.py
- Rubino - SimpleCov
Usando questi strumenti possiamo ottenere un rapporto di copertura completo dei nostri test che ci aiutano a sapere quale parte del codice verrebbe eseguita e quale sarebbe sfuggita ai nostri test.
Q # 3) La copertura del codice è una buona metrica?
Risposta: Negli scenari di vita reale, questo è utile in una certa misura e in alcuni modi particolari.
Guardando prima ai suoi limiti, sappiamo molto bene che avere una copertura del 100% non garantisce che il codice sia privo di bug, né garantisce che tutti i requisiti siano stati coperti dal codice, ovvero nonostante una copertura del codice del 100% lo siamo è molto probabile che ci siano bug nel codice, il motivo è che la copertura non garantisce che tutti gli scenari siano stati testati.
Inoltre, se i requisiti sono stati ignorati durante la scrittura del codice, non vi è alcuna mappatura dei requisiti con il codice che viene gestito come parte della Copertura del codice.
Detto questo, non possiamo negare che quando usiamo la Copertura del codice come metrica, ci dà un'idea se abbiamo coperto i requisiti di base per testare ogni riga del nostro codice. Questa percentuale di copertura ci dà un'idea di quante parti del nostro codice vengono eseguite con i nostri unit test.
Veniamo a sapere quanto del nostro codice sarebbe ineseguito. Questo a sua volta ci aiuta a decidere quanti più unit test sono necessari e per quali parti del codice.
Possiamo quindi concludere che avere una scarsa copertura ci dà un'idea dell'inefficacia degli unit test. Allo stesso tempo, garantire una copertura del 100% non è una garanzia per un codice privo di difetti. Quindi è necessario avere un approccio equilibrato in cui non enfatizziamo eccessivamente l'importanza di puntare a un'alta percentuale di copertura del codice.
Q # 4) Come posso migliorare la copertura del mio codice?
Risposta: Il Code Coverage Report fornito da strumenti di copertura come JaCoCo, Istanbul, ecc. Mostra le aree coperte dai test e anche quelle che non verrebbero testate.
Conoscendo le parti non testate del codice, i test possono essere scritti manualmente o utilizzando qualsiasi strumento di automazione per coprire le aree che altrimenti non verrebbero testate e quindi aumentare la copertura del codice.
Una cosa importante da notare qui è che mentre possiamo scrivere centinaia di righe di codice per testare una funzione nel codice, ma la copertura potrebbe essere molto inferiore. Il motivo è che approfondire troppo per testare una parte dell'enorme codice non aiuterà ad aumentare la copertura del codice.
Pertanto, se l'obiettivo è aumentare la copertura, è necessario prestare attenzione a coprire tutte le funzioni, condizioni e loop invece di immergersi in profondità in una singola funzione e scrivere test di grandi dimensioni per quella singola funzione.
Conclusione
Un prodotto software di alta qualità è ciò che è richiesto nel frenetico mondo di Internet di oggi.
Garantire un software di buona qualità non è solo responsabilità di un QA Engineer, ma è anche responsabilità dello sviluppatore. La copertura del codice è quindi di grande utilità quando si tratta di fornire un prodotto di qualità al team QA da parte degli sviluppatori.
Questo tutorial ha spiegato tutto sulla copertura del codice e sui suoi usi. Abbiamo anche approfondito la comprensione della differenza tra Copertura del codice e Copertura dei test. Oltre a questo, abbiamo compreso le metodologie utilizzate insieme a una varietà di strumenti di Code Coverage.
I vantaggi e gli svantaggi sono stati illustrati qui. Infine, abbiamo sfatato alcuni miti e domande frequenti associati alla copertura del codice
Buona lettura!!
Lettura consigliata
- I 15 migliori strumenti di copertura del codice (per Java, JavaScript, C ++, C #, PHP)
- 15 migliori strumenti JAVA per sviluppo, compilazione, profiler, copertura del codice e revisione
- Esercitazione su funzioni / metodi C # con esempi di codice
- Esercitazione sulla gestione delle eccezioni C # con esempi di codice
- Tutorial SVN tartaruga: revisioni nel repository di codice
- Tutorial sulla lunghezza di array Java con esempi di codice
- Tutorial AWS CodeBuild: estrazione del codice da Maven Build
- Tutorial SVN: gestione del codice sorgente mediante Subversion