Meniu

Tutorial privind acoperirea codului: ramură, declarație, acoperirea funcției

  • Principal
  • Alte
  • Tutorial privind acoperirea codului: ramură, declarație, acoperirea funcției

code coverage tutorial

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial cuprinzător explică ce este acoperirea codului în testarea software-ului, tipurile, beneficiile și dezavantajele sale:

Scopul final al oricărei companii de dezvoltare software este de a dezvolta software de bună calitate. Pentru a atinge acest obiectiv, software-ul trebuie testat temeinic.

Testarea este astfel o parte integrantă a dezvoltării unei aplicații software. Prin urmare, este esențial ca software-ul dezvoltat să fie revizuit de către dezvoltator (ceea ce se realizează în timpul fazei de testare a unității) și apoi să fie transmis echipei QC pentru a fi testat temeinic pentru a se asigura că are erori minime sau deloc.

Acoperirea codului

Software-ul este testat în unitate înainte de a fi lansat echipei de testare pentru testare. Deoarece această testare implică testarea la nivel de cod, aceasta este realizată de dezvoltator. Acest lucru se face pentru a se asigura că fiecare parte a codului testat funcționează conform așteptărilor.

Aici, mici bucăți de cod care au fost dezvoltate sunt testate izolat pentru a asigura corectitudinea lor. Însă, întrebarea care apare adesea în mintea unui dezvoltator este cât de mult trebuie testat unitatea iar răspunsul la aceasta se află în Acoperirea Codului.

Acest tutorial vă va oferi o cunoaștere profundă a ceea ce este acoperirea codului și de ce avem nevoie de el. Ați afla cum diferă de acoperirea testului.

De asemenea, vom arunca o privire asupra instrumentelor și metodologiilor utilizate pentru acoperirea codului și, spre sfârșitul acestui tutorial, vom vedea avantajele împreună cu dezavantajele sale. Unele dintre miturile asociate cu acoperirea codului ar fi, de asemenea, acoperite aici.

Ce veți învăța:

Ce este acoperirea codului

Acoperirea codului

Aceasta este o măsură importantă pentru testarea unității. Este util să cunoaștem eficacitatea testelor unitare. Este o măsură care indică ce procentaj din codul sursă ar fi executat în timpul testării.

In termeni simpli, măsura în care codul sursă al unui program software sau al unei aplicații va fi executat în timpul testării este ceea ce se numește acoperire cod.

Dacă testele execută întreaga bucată de cod, inclusiv toate ramurile, condițiile sau buclele, atunci am spune că există o acoperire completă a tuturor scenariilor posibile și, astfel, acoperirea codului este de 100%. Pentru a înțelege acest lucru și mai bine, să luăm un exemplu.

Dat mai jos este un cod simplu care este folosit pentru a adăuga două numere și a afișa rezultatul în funcție de valoarea rezultatului.

Input a, b Let c = a + b If c <10, print c Else, print ‘Sorry’

Programul de mai sus include două intrări, adică „a” și „b”. Suma ambelor este stocată în variabila c. Dacă valoarea lui c este mai mică de 10, atunci se imprimă valoarea „c” altfel se imprimă „Scuze”.

Acum, dacă avem unele teste pentru a valida programul de mai sus cu valorile lui a & b astfel încât suma să fie întotdeauna mai mică de 10, atunci cealaltă parte a codului nu se execută niciodată. Într-un astfel de scenariu, am spune că acoperirea nu este completă.

Acesta a fost doar un mic exemplu pentru a clarifica semnificația Codului de acoperire. Pe măsură ce vom explora mai multe, veți obține o mai mare claritate în acest sens.

De ce avem nevoie de acoperirea codului

Necesitatea acoperirii codului

(imagine sursă )

Diferite motive fac ca acoperirea codului să fie esențială și unele dintre acestea sunt enumerate mai jos:

instrumente de gestionare a ciclului de viață al aplicațiilor open source
  • Ajută la constatarea faptului că software-ul are erori mai mici în comparație cu software-ul care nu are o acoperire bună a codului.
  • Ajutând la îmbunătățirea calității codului, ajută indirect la furnizarea unui software de „calitate” mai bun.
  • Este o măsură care poate fi utilizată pentru a cunoaște eficacitatea testului (eficacitatea testelor unitare care sunt scrise pentru a testa codul).
  • Ajută la identificarea acelor părți ale codului sursă care ar rămâne netestate.
  • Ajută la determinarea dacă testarea curentă (testarea unitară) este suficientă sau nu și dacă sunt necesare și alte teste.

Cod Acoperire Vs Acoperire Test

CC Vs TC

Pentru a înțelege diferența dintre acoperirea codului și acoperirea testului, să înțelegem mai întâi semnificația acoperirii testului.

Acoperirea testului

Este o măsură a numărului de părți ale testării așteptate care au fost acoperite în timpul testării unui software. De „Testare așteptată” ne referim la setul complet de cazuri de test care sunt scrise pentru a fi executate pentru a testa un anumit software.

Să presupunem că pentru a testa un software s-au scris un set de 500 de cazuri de testare totale. Acum, ca parte a activității de testare, au fost executate doar 300 de cazuri de testare. Să presupunem că acest lucru se datorează lipsei de timp. În acest caz, mai jos ar fi acoperirea testului.

Acoperirea testului = (cazuri de testare executate / cazuri totale de testare) * 100
= (300/500) * 100
= 60%

Să comparăm acest lucru cu ceea ce este Acoperirea codului.

Acoperirea codului

Este o măsură care arată măsura în care un cod sursă al unei aplicații este executat în timpul testării codului. Arată astfel gradul în care un cod sursă ar fi testat.

Să presupunem că pentru a testa o aplicație cu 500 de linii de cod, doar 400 de linii ale codului sunt executate prin teste. Să presupunem că acest lucru se datorează unei anumite bucle / condiții care nu se execută. În acest caz, mai jos ar fi acoperirea codului.

Acoperirea codului = (numărul de linii de cod executate / numărul total de linii de cod) * 100
= (400/500) * 100
= 80%

Mai jos sunt enumerate diferențele dintre acoperirea codului și acoperirea testului:

Acoperirea testuluiAcoperirea codului
Este o măsură a cât de mult a fost acoperită o parte din testarea așteptată în timpul testării unui software.Este o măsură care arată măsura în care un cod sursă al unei aplicații este executat în timpul testării codului.
Acoperirea testului poate fi calculată folosind formula de mai jos:

Acoperirea testului = (cazuri de testare executate / cazuri totale de testare) * 100		Acoperirea codului poate fi calculată folosind formula de mai jos:

Acoperirea codului = (numărul de linii de cod executate / numărul total de linii de cod) * 100

Metodologii

Aici vom discuta diferitele metode care sunt / pot fi utilizate pentru a măsura acoperirea codului.

Pentru a înțelege aceste metodologii, să aruncăm o privire la fragmentul de cod de mai jos:

Add (int a, int b) { If (b > a) { b = b - a Print b } If (a > b) { b = a – b Print b } Else Print ‘0’ }

Acoperirea declarației

Această metodologie este o măsură care indică dacă toate declarațiile executabile posibile ale codului din codul sursă au fost executate cel puțin o dată. Este o metodă pentru a se asigura că fiecare linie a codului sursă este acoperită cel puțin o dată de teste.

Acest lucru ar putea părea simplu, dar trebuie să aveți grijă la măsurarea acoperirii declarației. Motivul este că într-un cod sursă ar putea exista o anumită condiție care ar putea să nu fie executată în funcție de valorile de intrare.

Acest lucru ar însemna că toate liniile de cod nu ar fi acoperite în testare. Astfel, este posibil să trebuiască să folosim seturi de valori de intrare diferite pentru a acoperi toate aceste condiții din codul sursă.

De exemplu, în codul sursă de mai sus, dacă valorile de intrare sunt luate ca 2 și 3, partea „Altfel” a codului nu va fi executată. Cu toate acestea, dacă valorile de intrare sunt de tipul 3 și 2, atunci partea „Dacă” din cod nu va fi executată.

Aceasta înseamnă că, cu oricare dintre seturile de valori ale Declarației noastre, acoperirea nu ar fi 100%. Într-un astfel de caz, este posibil să trebuiască să executăm testele cu toate cele trei ((2, 3), (3, 2), (0, 0)) set de valori pentru a asigura o acoperire a declarației de 100%.

Acoperirea funcției

După cum sugerează și numele, această metodologie măsoară măsura în care funcțiile prezente în codul sursă sunt acoperite în timpul testării. Toate funcțiile din codul sursă sunt testate în timpul executării testului. Din nou, trebuie să ne asigurăm că testăm aceste funcții pentru valori diferite, astfel încât funcția să fie testată temeinic.

Într-un cod sursă pot exista mai multe funcții și, în funcție de valorile de intrare utilizate, o funcție poate fi sau nu apelată. Astfel, scopul acoperirii funcției este de a ne asigura că avem fiecare funcție solicitată.

De exemplu, în codul sursă de mai sus, dacă testele noastre apelează funcția „Adăugare” chiar și o singură dată, atunci am numi aceasta ca o acoperire completă a funcției.

Acoperirea stării

Într-un cod sursă oriunde avem o condiție, rezultatul ar fi o valoare booleană fie adevărată, fie falsă. Acoperirea condiției vizează stabilirea dacă testele acoperă ambele valori, adică adevărat, fals.

În codul sursă, atunci când fiecare condiție care apare este evaluată atât pentru stări adevărate, cât și pentru stări false, atunci acoperirea condiției pentru cod se spune că este completă.

De exemplu, în codul de mai sus dacă sunt utilizate seturile de valori (2, 3) și (4, 2) atunci Acoperirea condiției ar fi 100%. Când se folosește setul de date (2, 3), atunci (b> a) se evaluează la adevărat și (a> b) se evaluează la fals. În mod similar, atunci când este utilizat setul de date (4, 2), atunci (b> a) se evaluează la fals și (a> b) se evaluează la adevărat.

Astfel, ambele condiții au atât valorile, adică adevărat, cât și fals, acoperite. Prin urmare, acoperirea condiției ar fi de 100%.

Acoperirea sucursalei

Această metodologie vizează asigurarea faptului că fiecare ramură care apare în fiecare structură condițională este executată în cod sursă. De exemplu, în codul de mai sus, toate declarațiile „Dacă” și orice declarație „Else” însoțitoare ar trebui să fie toate acoperite de testul pentru o acoperire de sucursală 100%.

De exemplu, în codul de mai sus dacă sunt utilizate seturile de valori (2, 3), (4, 2), (1, 1), atunci Acoperirea sucursalei ar fi 100%. Când este utilizat setul de date (2, 3), atunci (b> a) și prima ramură „Dacă” este executată. În mod similar, atunci când este utilizat setul de date (4, 2), atunci (a> b) se evaluează la adevărat și se execută a doua ramură „Dacă”.

Apoi, cu setul de date (1, 1) ramura „Altfel” se evaluează la adevărat și se execută. Astfel, asigurarea acoperirii 100% a sucursalei.

Acoperire sucursală Vs Condiție Acoperire

Acoperirea ramurii este adesea confundată cu acoperirea condiției, cu toate acestea, cele două sunt diferite.

Să înțelegem acest lucru cu un exemplu simplu.

If (a >0) & (b >0) Then Print “Hello” Else Print “Bye”

Haideți să notăm setul de date necesar pentru finalizare Acoperire sucursală:

(1, 1) - În acest caz, „a” și „b” sunt adevărate, deci condiția If este executată.
(1, 0) - În acest caz, „a” este adevărat și „b” ar fi fals, deci partea Else a codului este executată.

După cum știm, scopul acoperirii sucursalei este de a executa fiecare sucursală cel puțin o dată și acest scop este atins.

Acoperirea stării:

(1, 0) - În acest caz, „a” este adevărat și „b” ar fi fals.
(0, 1) - În acest caz, „a” este fals și „b” ar fi adevărat.

blocare pop-up gratuită pentru crom

Scopul acoperirii condițiilor este de a obține fiecare dintre adevărate și false pentru fiecare condiție executată și acest scop este atins aici.

Ați observat că partea opusă nu se execută în acoperirea condiției? Aici acoperirea condiției diferă de acoperirea sucursalei.

Instrumente pentru acoperirea codului

Pentru a măsura acoperirea codului oricărui software, există mai multe instrumente disponibile pe piață.

Mai jos sunt enumerate câteva dintre instrumentele de referință:

  • Parasoft JTest
  • Testwell CTC ++
  • Acoperire
  • JaCoCo
  • CodeCover
  • BullseyeCoverage
  • EMMA
  • OpenCover
  • NCover
  • Squish COCO
  • CoverageMeter
  • GCT
  • TCAT C / C ++
  • Gretel
  • JCov

Lectură recomandată => Instrumente de acoperire a codului

Linkul de mai sus va include următoarele informații despre aceste instrumente:

  • Caracteristici cheie
  • Tipul licenței
  • Adresa URL oficială
  • Argumente pro şi contra
  • Ultima versiune

Beneficii

După cum s-a văzut mai sus, este o măsurătoare de testare foarte utilă din motivele de mai jos:

  • Ajută la identificarea acelor zone dintr-un cod sursă care ar rămâne netestate / neacoperite de teste.
  • Este util să identificăm codul folosit / mort, îmbunătățind astfel calitatea codului.
  • Eficacitatea testelor unitare poate fi cunoscută cu ajutorul Codului de acoperire.
  • Software-ul cu o calitate mai bună poate fi livrat folosind aceste valori.

Dezavantaje

  • Încercarea de a viza o acoperire 100% a codului determină uneori lipsa de robustețe a testelor, ceea ce duce la pierderea capturării scenariilor predispuse la defecte.
  • Spre deosebire de percepția comună, nu poate garanta dacă software-ul proiectat satisface toate cerințele.

Mituri Vs Fapte

MitFapt
Având o acoperire 100% a codului, se asigură că software-ul nu va avea erori.Nu, acoperirea 100% a codului nu poate garanta software-ul fără erori. O bună acoperire a codului, combinată cu eforturi bune din partea echipei QC, poate asigura un software cu bug-uri minime sau deloc.
A avea 100% acoperire de cod înseamnă că codul scris este perfect.Nu, de fapt, dacă cerințele importante nu au fost surprinse de cod în primul rând, atunci codul nu poate fi numit perfect, deși acoperirea codului este 100%.
Acoperirea codului măsoară eficiența testelor efectuate pe un produs software.Nu, acoperirea codului este doar o măsură care este utilizată pentru a testa eficiența testelor unitare, adică a testelor executate numai pe codul sursă al unui software.

Întrebări frecvente

Q # 1) Ce este o acoperire acceptabilă a codului?

Răspuns: Obținerea acoperirii 100% a codului nu ar trebui să fie obiectivul în timpul testării unității a codului software. Dar de ce nu? Pentru a înțelege motivul pentru care trebuie să vă scufundați puțin mai adânc pentru a înțelege semnificația subiacentă.

Când vizăm o acoperire de 100%, atunci se întâmplă mai des ca toată concentrarea în proiectarea testelor să se asigure dacă fiecare instrucțiune, buclă, ramură sau condiție este testată. Așadar, ajungem să depunem prea multe eforturi care ar putea să nu merite luând în considerare timpul petrecut.

cum se deschid fișiere jar pe Windows 10

Mai mult decât atât, concentrarea pe o acoperire ridicată are ca rezultat pierderea scenariilor importante care sunt susceptibile să aibă defecte, deoarece tot ceea ce vizăm este să ne asigurăm că fiecare linie de cod este testată.

Concentrarea pe o acoperire de cod ridicată nu este atât de importantă întotdeauna și nici nu poate fi un număr fix pentru a viza pentru a testa diferite coduri. Cu toate acestea, în general, o acoperire de 75% - 80% ar trebui să fie un număr ideal.

În timpul testării codului nostru, accentul principal ar trebui să fie asigurarea acoperirii scenariilor critice și probabile cu erori. Dacă acestea sunt ratate, în ciuda faptului că au o acoperire de cod 100%, testele noastre ar avea pur și simplu o eficiență redusă a testelor.

Q # 2) Cum îmi verific acoperirea codului?

Răspuns: Pentru a testa procentul de acoperire a codului pe care l-ați fi realizat prin testele concepute pentru testarea codului, avem mai multe instrumente pe piață. În funcție de limbajul de programare pe care îl folosiți, avem diverse instrumente.

Unele dintre ele sunt enumerate mai jos:

  • Java - Acoperire, JaCoCo
  • Javascript - Blanket.js, Istanbul
  • Piton - Coverage.py
  • Rubin - SimpleCov

Folosind aceste instrumente putem obține un raport complet de acoperire a testelor noastre care ne ajută să știm ce parte a codului ar fi executată și care ar fi ratată de testele noastre.

Q # 3) Codul acoperire este o valoare bună?

Răspuns: În scenariile din viața reală, acest lucru este util într-o anumită măsură și în anumite moduri particulare.

Privind mai întâi limitările sale, știm foarte bine că a avea o acoperire de 100% nu garantează că Codul nu conține erori și nici nu garantează că toate cerințele au fost acoperite în cod, adică în ciuda unei acoperiri a codului de 100%, suntem foarte probabil să aibă erori în cod, motivul fiind că acoperirea nu asigură că toate scenariile au fost testate.

Mai mult, dacă cerințele au fost omise în timpul redactării codului, atunci nu există o mapare a cerințelor cu codul care este luat în considerare ca parte a acoperirii codului.

Acestea fiind spuse, nu putem nega faptul că, atunci când folosim acoperirea codului ca valori, ne oferă o idee dacă am acoperit cerințele de bază ale testării fiecărei linii a codului nostru. Acest procentaj de acoperire ne oferă o idee despre câte părți ale codului nostru sunt executate cu testele noastre unitare.

Am aflat cât din codul nostru ar fi neexecutat. La rândul nostru, acest lucru ne ajută să decidem cât de multe teste unitare sunt necesare și pentru ce părți ale codului.

Astfel putem concluziona că a avea o acoperire slabă ne oferă o idee despre ineficacitatea testelor unitare. În același timp, asigurarea unei acoperiri de 100% nu este o garanție pentru un cod fără defecte. Astfel, trebuie să avem o abordare echilibrată în care să nu subliniem în exces importanța vizării unui procent ridicat de acoperire a codului.

Q # 4) Cum îmi pot îmbunătăți acoperirea codului?

Răspuns: Raportul de acoperire a codului, care este furnizat de instrumente de acoperire, cum ar fi JaCoCo, Istanbul etc., arată zonele care sunt acoperite de teste și, de asemenea, cele care ar rămâne netestate.

Cunoscând părțile netestate ale codului, testele pot fi scrise fie manual, fie utilizând orice instrument de automatizare pentru a acoperi zonele care altfel ar rămâne netestate și, prin urmare, ar crește acoperirea codului.

Un lucru important de remarcat aici este că, deși putem scrie sute de linii de cod pentru a testa o funcție în cod, dar totuși acoperirea ar putea fi foarte mică. Motivul este că a ajunge prea adânc pentru a testa o parte din codul uriaș nu va ajuta la creșterea acoperirii codului.

Astfel, dacă ținta este de a crește acoperirea, atunci trebuie să avem grijă să acoperim toate funcțiile, condițiile și buclele în loc să ne scufundăm într-o singură funcție și să scriem teste mari pentru acea funcție.

Concluzie

Un produs software de înaltă calitate este ceea ce este necesar în lumea internetului de ritm rapid de astăzi.

Asigurarea unui software de bună calitate nu este doar responsabilitatea unui inginer QA, ci este și responsabilitatea dezvoltatorului. Acoperirea codului este, prin urmare, de mare folos atunci când vine vorba de livrarea unui produs de calitate către echipa QA de către dezvoltatori.

Acest tutorial a explicat totul despre acoperirea codului și utilizările sale. De asemenea, am aprofundat puțin înțelegerea diferenței dintre acoperirea codului și acoperirea testului. Pe lângă aceasta, am înțeles metodologiile utilizate împreună cu o varietate de instrumente de acoperire a codului.

Avantajele și dezavantajele au fost prezentate aici. În cele din urmă, am eliminat unele dintre mituri și întrebări frecvente asociate cu acoperirea codului

Lectura placuta!!

Lectură recomandată

^