Tutorial privind acoperirea codului: testarea ramurilor, declarațiilor și deciziilor

Ce este acoperirea codului?

Acoperirea codului este o măsură care descrie gradul în care codul sursă al programului a fost testat. Este o formă de testare cu casetă albă care găsește zonele programului care nu sunt exercitate de un set de cazuri de testare. De asemenea, creează câteva cazuri de testare pentru a crește acoperirea și pentru a determina o măsură cantitativă a acoperirii codului.

În cele mai multe cazuri, sistemul de acoperire a codului adună informații despre programul care rulează. De asemenea, combină acest lucru cu informații despre codul sursă pentru a genera un raport despre acoperirea codului suitei de testare.

De ce să folosiți Testarea Acoperirii Codului?

Iată câteva motive principale pentru a utiliza acoperirea codului:

• Vă ajută să măsurați eficiența implementării testului
• Oferă o măsurătoare cantitativă.
• Acesta definește gradul în care codul sursă a fost testat.

Metode de acoperire a codului

Mai jos sunt principalele metode de acoperire a codului

• Acoperirea declarației
• Acoperirea deciziei
• Acoperire sucursală
• Toggle Acoperire
• Acoperire FSM

Acoperirea declarației

Acoperirea declarației este o tehnică de testare cutie albă în care toate instrucțiunile executabile din codul sursă sunt executate cel puțin o dată. Este folosit pentru calcularea numărului de instrucțiuni din codul sursă care au fost executate. Scopul principal al Statement Coverage este de a acoperi toate căile, liniile și declarațiile posibile din codul sursă.

Acoperirea declarațiilor este utilizată pentru a deriva scenariul bazat pe structura codului testat.

In Alb Box Testarea, testerul se concentrează asupra modului în care funcționează software-ul. Cu alte cuvinte, testerul se va concentra pe funcționarea internă a codului sursă în ceea ce privește graficele de flux de control sau diagramele de flux.

În general, în orice software, dacă ne uităm la codul sursă, va exista o mare varietate de elemente precum operatori, funcții, bucle, handlere excepționale etc. Pe baza intrării în program, unele dintre instrucțiunile de cod pot să nu fie executate. . Scopul acoperirii Statement este să acopere toate căile, liniile și instrucțiunile posibile din cod.

Să înțelegem acest lucru cu un exemplu, cum să calculăm acoperirea declarațiilor.

Scenariu pentru a calcula acoperirea declarației pentru codul sursă dat. Aici luăm două scenarii diferite pentru a verifica procentul de acoperire a declarațiilor pentru fiecare scenariu.

Cod sursa:

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 

Scenariul 1:

Dacă A = 3, B = 9

Declarațiile marcate cu culoarea galbenă sunt cele care sunt executate conform scenariului

Numărul de instrucțiuni executate = 5, Numărul total de instrucțiuni = 7

Acoperire declarație: 5/7 = 71%

La fel vom vedea scenariul 2,

Scenariul 2:

Dacă A = -3, B = -9

Declarațiile marcate cu culoarea galbenă sunt cele care sunt executate conform scenariului.

Numărul de instrucțiuni executate = 6

Numărul total de declarații = 7

Acoperire declarație: 6/7 = 85%

Dar, în general, dacă vedeți, toate afirmațiile sunt acoperite de ambele scenarii. Deci putem concluziona că acoperirea generală a declarațiilor este de 100%.

Ce este acoperit de Acoperirea declarațiilor?

1. Declarații neutilizate
2. Cod mort
3. Ramuri nefolosite
4. Declarații lipsă

Testarea acoperirii deciziilor

Acoperirea deciziei este o tehnică de testare cutie albă care raportează rezultatele adevărate sau false ale fiecărei expresii booleene a codului sursă. Scopul testării acoperirii deciziilor este de a acoperi și valida tot codul sursă accesibil prin verificarea și asigurarea faptului că fiecare ramură a fiecărui punct de decizie posibil este executată cel puțin o dată.

În acest tip de acoperire, expresiile pot deveni complexe, ceea ce face dificilă obținerea unei acoperiri de 100%. Acesta este motivul pentru care sunt utilizate diferite metode pentru a raporta această măsură. Aceste metode prioritizează cele mai critice combinații. Deși este similar cu acoperirea deciziei, oferă o mai mare sensibilitate la fluxul de control.

Exemplu de acoperire a deciziilor

Luați în considerare următorul cod -

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

Scenariul 1:

Valoarea lui a este 2

Codul evidențiat cu galben va fi executat. Aici este bifat rezultatul „Nu” al deciziei Dacă (a>5).

Acoperire de decizie = 50%

Scenariul 2:

Valoarea lui a este 6

Codul evidențiat cu galben va fi executat. Aici este bifat rezultatul „Da” al deciziei Dacă (a>5).

Acoperire de decizie = 50%

Caz de testare	Valoarea lui A	producție	Acoperirea deciziei
1	2	2	50%
2	6	18	50%

Testarea acoperirii filialelor

Acoperire sucursală este o metodă de testare cutie albă în care fiecare rezultat dintr-un modul de cod (instrucțiune sau buclă) este testat. Scopul acoperirii sucursalei este de a se asigura că fiecare condiție de decizie din fiecare sucursală este executată cel puțin o dată. Ajută la măsurarea fracțiilor de segmente de cod independente și la aflarea secțiunilor care nu au ramuri.

De exemplu, dacă rezultatele sunt binare, trebuie să testați atât rezultatele adevărate, cât și cele false.

Formula de calcul a acoperirii sucursalei:

Exemplu de acoperire a filialei

Pentru a afla acoperirea ramurilor, să luăm în considerare același exemplu folosit mai devreme

Luați în considerare următorul cod -

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

Acoperirea filialei va lua în considerare și sucursala necondiționată

Caz de testare	Valoarea lui A	producție	Acoperirea deciziei	Acoperire sucursală
1	2	2	50%	33%
2	6	18	50%	67%

Avantajele acoperirii sucursalei:

Acoperirea ramurilor Testarea oferă următoarele avantaje:

• Vă permite să validați toate ramurile din cod
• Vă ajută să vă asigurați că nicio ramificare nu duce la vreo anomalie a funcționării programului
• Metoda de acoperire a ramurilor elimină problemele care apar din cauza testării acoperirii declarațiilor
• Vă permite să găsiți acele zone care nu sunt testate prin alte metode de testare
• Vă permite să găsiți o măsură cantitativă a acoperirii codului
• Acoperirea ramurilor ignoră ramurile din interiorul expresiilor booleene

Testarea acoperirii stării

Acoperire condiție sau acoperirea expresiei este o metodă de testare utilizată pentru a testa și evalua variabilele sau sub-expresiile din declarația condiționată. Scopul acoperirii condiției este de a verifica rezultatele individuale pentru fiecare condiție logică. Acoperirea condițiilor oferă o mai bună sensibilitate la fluxul de control decât acoperirea deciziei. În această acoperire, sunt luate în considerare doar expresiile cu operanzi logici.

De exemplu, dacă o expresie are operații booleene precum AND, OR, XOR, ceea ce indică posibilități totale.

Acoperirea condiției nu oferă o garanție cu privire la acoperirea completă a deciziei.

Formula pentru calcularea Acoperirii Condiției:

Exemplu:

Pentru expresia de mai sus, avem 4 combinații posibile

• TT
• FF
• TF
• FT

Luați în considerare următoarea intrare

X = 3 Y=4	(X	TRUE	Acoperirea condiției este ¼ = 25%
A = 3 B = 4	(a>b)	FALS

Acoperire cu mașini cu stări finite

Acoperirea mașinii cu stări finite este cu siguranță cel mai complex tip de metodă de acoperire a codului. Acest lucru se datorează faptului că funcționează asupra comportamentului designului. În această metodă de acoperire, trebuie să căutați câte state specifice de timp sunt vizitate, tranzitate. De asemenea, verifică câte secvențe sunt incluse într-o mașină cu stări finite.

Ce tip de acoperire a codului să alegeți

Acesta este cu siguranță cel mai dificil răspuns de dat. Pentru a selecta o metodă de acoperire, testerul trebuie să verifice dacă

• codul testat are un singur sau mai multe defecte nedescoperite
• costul eventualei sancțiuni
• costul pierderii reputației
• costul vânzării pierdute etc.

Cu cât este mai mare probabilitatea ca defectele să provoace eșecuri costisitoare de producție, cu atât mai sever este nivelul de acoperire pe care trebuie să-l alegeți.

Acoperirea codului vs. Acoperirea funcțională

Acoperirea codului	Acoperire funcțională
Acoperirea codului vă spune cât de bine a fost exercitat codul sursă de banca dvs. de testare.	Acoperirea funcțională măsoară cât de bine a fost acoperită funcționalitatea designului de banca dvs. de testare.
Nu utilizați niciodată o specificație de proiectare	Utilizați specificația de proiectare
Realizat de dezvoltatori	Realizat de testeri

Instrumente de acoperire a codului

Iată o listă de instrumente importante de acoperire a codului:

Numele instrumentului	Descriere
Cobertura	Este un instrument de acoperire a codului open source. Măsoară acoperirea testului prin instrumentarea unei baze de cod și analizează ce linii de cod se execută și care nu sunt executate atunci când rulează suita de teste.
Trifoi	Clover reduce, de asemenea, timpul de testare prin rularea numai a testelor care acoperă codul aplicației care a fost modificat de la versiunea anterioară.
DevPartner	DevPartner permite dezvoltatorilor să analizeze Java cod pentru calitatea codului și complexitatea.
Emma	EMMA acceptă niveluri de clasă, metodă, linie și bloc de bază, fișier sursă agregat, clasă și niveluri de metodă.
Kalistick	Kalistick este o aplicație terță care analizează codurile din perspective diferite.
CoView și CoAnt	Software-ul de codare este un instrument de acoperire a codului pentru metrici, crearea de obiecte simulate, testarea codului, acoperirea căilor și ramurilor etc.
Bullseye pentru C++	BulseyeCoverage este un instrument de acoperire a codului pentru C++ și C.
Sonar	Sonar este un instrument de acoperire a codului deschis care vă ajută să gestionați calitatea codului.

Avantajele și dezavantajele utilizării acoperirii codului

Avantajele acoperirii codului	Dezavantaje privind acoperirea codului
Util pentru a evalua o măsură cantitativă a acoperirii codului	Chiar și atunci când nicio caracteristică specifică nu este implementată în proiectare, acoperirea codului încă raportează o acoperire de 100%.
Vă permite să creați cazuri de testare suplimentare pentru a crește acoperirea	Nu este posibil să se stabilească dacă am testat toate valorile posibile ale unei caracteristici cu ajutorul acoperirii codului
Vă permite să găsiți zonele unui program care nu sunt exercitate de un set de cazuri de testare	Acoperirea codului nu spune nici cât de mult și cât de bine v-ați acoperit logica
	În cazul în care funcția specificată nu a fost implementată sau nu este inclusă din specificație, tehnicile bazate pe structură nu pot găsi problema respectivă.

Rezumat

• Acoperirea codului este o măsură care descrie gradul în care a fost testat codul sursă al programului
• Vă ajută să măsurați eficiența implementării testului
• Cinci metode de acoperire a codului sunt 1.) Acoperirea declarației 2.) Acoperirea stării 3) Acoperirea filialei 4) Toggle Acoperire 5) Acoperire FSM
• Acoperirea declarațiilor implică execuția tuturor instrucțiunilor executabile din codul sursă cel puțin o dată
• Acoperirea deciziei raportează rezultatele adevărate sau false ale fiecărei expresii booleene
• În acoperirea ramurilor, fiecare rezultat dintr-un modul de cod este testat
• Condițional va dezvălui cum sunt evaluate variabilele sau subexpresiile din instrucțiunea condiționată
• Acoperirea mașinii cu stări finite este cu siguranță cel mai complex tip de metodă de acoperire a codului
• Pentru a selecta o metodă de acoperire, testerul trebuie să verifice costul penalizării potențiale, pierderea reputației, pierderea vânzării etc.
• Acoperirea codului vă spune cât de bine a fost exercitat codul sursă de bancul dvs. de testare, în timp ce acoperirea funcțională măsoară cât de bine a fost acoperită funcționalitatea designului
• Cobertura, JTest, Clover, Emma, ​​Kalistick sunt câteva instrumente importante de acoperire a codului
• Acoperirea codului vă permite să creați cazuri de testare suplimentare pentru a crește acoperirea
• Acoperirea codului nu vă ajută să determinați dacă am testat toate valorile posibile ale unei caracteristici