code coverage tutorial
Aquest tutorial complet explica què és la cobertura del codi en les proves de programari, els seus tipus, avantatges i inconvenients:
L’objectiu final de qualsevol empresa de desenvolupament de programari és desenvolupar programari de bona qualitat. Per assolir aquest objectiu, cal provar a fons el programari.
Per tant, les proves són una part integral del desenvolupament d’una aplicació de programari. Per tant, és essencial que el programari desenvolupat sigui revisat pel desenvolupador (que es realitza durant la fase de prova de la unitat) i després es passi a l’equip de control de qualitat perquè es provi a fons per assegurar-se que tingui errors mínims o nuls.
El programari es prova a la unitat abans de ser llançat a l'equip de proves real per a la prova. Com que aquesta prova implica proves a nivell de codi, la realitza el desenvolupador. Això es fa per garantir que cada part del codi que s'està provant funcioni com s'esperava.
Aquí, petits fragments de codi que s'han desenvolupat es posen a prova aïlladament per assegurar-ne la correcció. Però, la pregunta que sovint apareix a la ment d’un desenvolupador és quant s'haurien de fer proves d'unitats i la resposta a això es troba en la cobertura del codi.
Aquest tutorial us proporcionarà un coneixement profund de què és la cobertura del codi i per què la necessitem. Sabríeu com difereix de la cobertura de les proves.
També veurem les eines i metodologies que s’utilitzen per a la cobertura del codi i, cap al final d’aquest tutorial, veurem els avantatges i els seus inconvenients. Alguns dels mites associats a la cobertura del codi també es tractarien aquí.
Què aprendreu:
Què és la cobertura del codi
Aquesta és una mètrica important de proves d’unitats. És útil conèixer l’eficàcia de les proves unitàries. És una mesura que indica quin percentatge de codi font s’executaria durant la prova.
En termes simples, la mesura en què s'executarà el codi font d'un programa o aplicació durant les proves és el que s'anomena cobertura de codi.
Si les proves executen tot el fragment de codi, incloses totes les branques, condicions o bucles, diríem que hi ha una cobertura completa de tots els escenaris possibles i, per tant, la cobertura del codi és del 100%. Per entendre-ho encara millor, posem un exemple.
A continuació es mostra un codi simple que s’utilitza per afegir dos números i mostrar el resultat en funció del valor del resultat.
Input a, b Let c = a + b If c <10, print c Else, print ‘Sorry’El programa anterior inclou dues entrades, és a dir, 'a' & 'b'. La suma de tots dos s’emmagatzema a la variable c. Si el valor de c és inferior a 10, s'imprimeix el valor de 'c', en cas contrari s'imprimeix 'Disculpeu'.
Ara bé, si tenim algunes proves per validar el programa anterior amb els valors de a & b de manera que la suma sigui sempre inferior a 10, llavors la resta del codi no s'executa mai. En aquest cas, diríem que la cobertura no és completa.
Aquest va ser només un petit exemple per aclarir el significat de la cobertura del codi. A mesura que explorem més, obtindreu més claredat al respecte.
Per què necessitem la cobertura del codi
(imatge font )
Diverses raons fan que la cobertura del codi sigui essencial i algunes d’elles es detallen a continuació:
millors aplicacions d’escriptura per a Windows 10
- Ajuda a comprovar que el programari té errors menors en comparació amb el programari que no té una bona cobertura de codi.
- En ajudar a millorar la qualitat del codi, indirectament ajuda a oferir un programari de 'qualitat' millor.
- És una mesura que es pot utilitzar per conèixer l’eficàcia de les proves (efectivitat de les proves unitàries que s’escriuen per provar el codi).
- Ajuda a identificar aquelles parts del codi font que quedarien sense provar.
- Ajuda a determinar si les proves actuals (proves unitàries) són suficients o no i si també calen algunes proves més.
Cobertura del codi contra la cobertura de la prova
Per entendre la diferència entre la cobertura del codi i la cobertura de la prova, primer entenem el significat de la cobertura de la prova.
Cobertura de la prova
És una mesura de quantes parts de les proves esperades s'han cobert durant la prova d'un programari. Per 'Proves esperades' ens referim al conjunt complet de casos de prova que s’escriuen per executar-se per provar un determinat programari.
Suposem que per provar un programari s’han escrit un conjunt de 500 casos de proves totals. Ara, com a part de l'activitat de proves, només es van executar 300 casos de prova. Suposem que això es deu a la manca de temps. En aquest cas, el següent seria la cobertura de la prova.
Cobertura de la prova = (casos de prova executats / casos de proves totals) * 100
= (300/500) * 100
= 60%
Comparem això amb el que és la cobertura del codi.
Cobertura del codi
És una mesura que mostra fins a quin punt s’executa un codi font d’una aplicació durant la prova del codi. Per tant, mostra el grau en què es provaria un codi font.
com fer el vostre propi tallafoc
Suposem que per provar una aplicació amb 500 línies de codi, només 400 línies del codi s’executen mitjançant proves. Suposem que això es deu a que un determinat bucle / condició no s’executa. En aquest cas, el següent seria la cobertura del codi.
Cobertura del codi = (nombre de línies de codi executades / nombre total de línies de codi) * 100
= (400/500) * 100
= 80%
A continuació es detallen les diferències entre la cobertura del codi i la cobertura de les proves:
| Cobertura de la prova | Cobertura del codi |
|---|---|
| És una mesura de la part de les proves esperades que s’ha cobert durant la prova d’un programari. | És una mesura que mostra fins a quin punt s’executa un codi font d’una aplicació durant la prova del codi. |
| La cobertura de la prova es pot calcular mitjançant la fórmula següent: Cobertura de la prova = (casos de prova executats / casos de proves totals) * 100 | La cobertura del codi es pot calcular mitjançant la fórmula següent: Cobertura del codi = (nombre de línies de codi executades / nombre total de línies de codi) * 100 |
Metodologies
Aquí analitzarem els diversos mètodes que es poden utilitzar per mesurar la cobertura del codi.
Per entendre aquestes metodologies, fem una ullada al fragment de codi següent:
Add (int a, int b) { If (b > a) { b = b - a Print b } If (a > b) { b = a – b Print b } Else Print ‘0’ }Cobertura de la declaració
Aquesta metodologia és una mesura que indica si totes les sentències executables de codi del codi font s’han executat almenys una vegada. És un mètode per assegurar que cada línia del codi font sigui coberta almenys una vegada per les proves.
Pot semblar senzill, però cal tenir precaució en mesurar la cobertura de la declaració. La raó és que, en un codi font, podria existir una determinada condició que pot no executar-se en funció dels valors d'entrada.
Això significaria que no es cobririen totes les línies de codi en les proves. Per tant, potser haurem d’utilitzar diferents conjunts de valors d’entrada per cobrir totes aquestes condicions del codi font.
Per exemple, al codi font anterior, si es prenen els valors d’entrada com a 2 i 3, la part ‘Else’ del codi no s’executaria. Tanmateix, si els valors d’entrada són del tipus 3 i 2, la part del codi “Si” no s’executaria.
Això significa que amb qualsevol dels conjunts de valors de la nostra declaració, la cobertura no seria del 100%. En aquest cas, és possible que hàgim d’executar les proves amb els tres conjunts de valors ((2, 3), (3, 2), (0, 0)) per garantir una cobertura del 100% de la declaració.
Cobertura de la funció
Com el seu nom indica, aquesta metodologia mesura fins a quin punt es cobreixen les funcions presents al codi font durant les proves. Totes les funcions del codi font es proven durant l'execució de la prova. Una vegada més, s'ha d'assegurar que provem aquestes funcions per a valors variables de manera que la funció es provi a fons.
En un codi font pot haver-hi diverses funcions i, en funció dels valors d'entrada utilitzats, es pot anomenar o no una funció. Per tant, el propòsit de la cobertura de funcions és assegurar-nos que es requereixi cada funció.
Per exemple, al codi font anterior, si les nostres proves criden la funció 'Afegeix' fins i tot una vegada, en diríem una cobertura de funcions completa.
Condició Cobertura
En un codi font, sempre que tinguem una condició, el resultat seria un valor booleà veritable o fals. La cobertura de la condició té per objectiu establir si les proves cobreixen els dos valors, és a dir, vertader, fals.
Al codi font, quan cada condició que es produeix s’avalua tant per als estats vertader com fals, es diu que la cobertura de condicions del codi és completa.
Per exemple, al codi anterior si s'utilitzen els conjunts de valors (2, 3) i (4, 2), la cobertura de la condició seria del 100%. Quan s'utilitza el conjunt de dades (2, 3), llavors (b> a) avalua com a vertader i (a> b) avalua com a fals. De la mateixa manera, quan s'utilitza el conjunt de dades (4, 2), llavors (b> a) avalua com a fals i (a> b) avalua com a veritable.
Per tant, ambdues condicions tenen coberts els valors, és a dir, vertader i fals. Per tant, la cobertura de la condició seria del 100%.
Cobertura de sucursal
Aquesta metodologia té com a objectiu garantir que totes les branques que apareixen a cada estructura condicional s’executin en codi font. Per exemple, al codi anterior, totes les declaracions 'Si' i qualsevol declaració 'Else' que s'acompanyi haurien d'estar cobertes per la prova d'una cobertura de sucursal del 100%.
Per exemple, al codi anterior si s'utilitzen conjunts de valors (2, 3), (4, 2), (1, 1), la cobertura de la sucursal seria del 100%. Quan s’utilitza el conjunt de dades (2, 3) (b> a) i s’executa la primera branca ‘Si’. De la mateixa manera, quan s’utilitza el conjunt de dades (4, 2), llavors (a> b) es valora com a vertader i s’executa la segona branca ‘Si’.
A continuació, amb el conjunt de dades (1, 1), la branca 'Else' avalua com a veritable i s'executa. D’aquesta manera, s’assegura un 100% de cobertura de sucursal
Cobertura de sucursal Vs Condició Cobertura
La cobertura de la branca sovint es confon amb la cobertura de la condició, però, les dues són diferents.
Anem a entendre-ho amb un exemple senzill.
If (a >0) & (b >0) Then Print “Hello” Else Print “Bye”Anotem el conjunt de dades necessari per completar-lo Cobertura de sucursal:
(1, 1): en aquest cas, 'a' i 'b' són certes, de manera que la condició If s'executa.
(1, 0): en aquest cas, 'a' és cert i 'b' seria fals, de manera que s'executa la part Else del codi.
Com sabem, el propòsit de la cobertura de sucursal és aconseguir que totes les sucursals s’executin almenys una vegada i s’assoleixi aquest propòsit.
Cobertura de l'estat:
(1, 0): en aquest cas, 'a' és cert i 'b' seria fals.
(0, 1): en aquest cas, 'a' és falsa i 'b' seria certa.
El propòsit de la cobertura de la condició és obtenir cert i fals de cada condició executada i aquest propòsit s’aconsegueix aquí.
Heu notat que l'altra part no s'executa a la cobertura de la condició? Aquí és on la cobertura de les condicions difereix de la cobertura de la sucursal.
Eines per a la cobertura del codi
Per mesurar la cobertura del codi de qualsevol programari, hi ha diverses eines disponibles al mercat.
A continuació, es detallen algunes de les eines per a la vostra referència:
- Parasoft JTest
- Testwell CTC ++
- cobertura
- JaCoCo
- CodeCover
- BullseyeCoverage
- EMMA
- OpenCover
- NCover
- Squish COCO
- CoverageMeter
- GCT
- TCAT C / C ++
- Gretel
- JCov
Lectura recomanada => Eines de cobertura de codi
L’enllaç anterior inclourà la informació següent sobre aquestes eines:
- Característiques clau
- Tipus de llicència
- URL oficial
- Pros i contres
- Última versió
Beneficis
Com es va veure més amunt, és una mètrica de prova molt útil pels motius següents:
- Ajuda a identificar aquelles àrees en un codi font que les proves continuarien sense provar / descobrir.
- És útil identificar el codi utilitzat / mort per millorar la qualitat del codi.
- L'eficàcia de les proves unitàries es pot conèixer amb l'ajut de Code Coverage.
- Es pot subministrar programari de millor qualitat mitjançant aquestes mètriques.
Inconvenients
- Intentar intentar una cobertura del 100% del codi de vegades provoca una manca de robustesa de les proves, cosa que provoca la pèrdua de la captura dels escenaris propensos als defectes.
- A diferència de la percepció comuna, no pot garantir si el programari dissenyat compleix tots els requisits.
Mites vs. Fets
| Mite | Fet |
|---|---|
| Tenir un 100% de cobertura de codi garanteix que el programari no tingui errors. | No, la cobertura del codi al 100% no pot garantir un programari lliure d'errors. Una bona cobertura del codi juntament amb els bons esforços de l’equip de control de qualitat poden garantir un programari amb errors mínims o sense. |
| Tenir un 100% de cobertura de codi significa que el codi escrit és perfecte. | No, de fet, si els requisits importants no han estat capturats pel codi en primer lloc, el codi no es pot qualificar de perfecte malgrat que la cobertura del codi sigui del 100%. |
| La cobertura del codi mesura l’eficàcia de les proves realitzades en un producte de programari. | No, la cobertura del codi és només una mesura que s’utilitza per comprovar l’eficàcia de les proves unitàries, és a dir, les proves executades només al codi font d’un programari. |
Preguntes freqüents
P # 1) Què és una cobertura de codi acceptable?
Resposta: Assolir el 100% de cobertura de codi no hauria de ser l’objectiu mentre es provava el codi de programari de la unitat. Però, per què no? Per entendre el motiu, és possible que hagueu de bussejar una mica més per entendre el significat subjacent.
Quan ens orientem a una cobertura del 100%, més sovint passa que tot el focus en dissenyar les proves es dedica a assegurar si cada instrucció, bucle, branca o condició es prova. Així doncs, arribem a fer massa esforços que potser no valdria la pena tenir en compte el temps dedicat.
A més, centrar-se en una elevada cobertura també resulta en perdre els escenaris importants que probablement tinguin els defectes, perquè tot el que pretenem és assegurar-nos que es prova cada línia de codi.
Centrar-se en una cobertura de codi elevat no sempre és tan important i tampoc no pot ser un número fix a orientar per provar codis diferents. No obstant això, en general, una cobertura del 75% al 80% hauria de ser un nombre ideal.
Mentre provem el nostre codi, l’objectiu principal hauria de ser assegurar-se de cobrir els escenaris crítics i probables propensos als errors. Si es perden, tot i tenir una cobertura del codi del 100%, les nostres proves tindrien una efectivitat deficient.
ulleres de realitat virtual per a Xbox One
Q # 2) Com puc comprovar la cobertura del meu codi?
Resposta: Per provar el percentatge de cobertura del codi que haureu aconseguit amb les proves dissenyades per provar el codi, tenim diverses eines al mercat. En funció del llenguatge de programació que utilitzeu, disposem de diverses eines.
Alguns d’ells es detallen a continuació:
- Java - Cobertura, JaCoCo
- Javascript - Blanket.js, Istanbul
- Python - Coverage.py
- Rubí - SimpleCov
Mitjançant aquestes eines podem obtenir un informe de cobertura complet de les nostres proves que ens ajudaran a saber quina part del codi s’executaria i quines es perdrien per les nostres proves.
Q # 3) La cobertura del codi és una bona mètrica?
Resposta: En escenaris de la vida real, això és útil fins a cert punt i d'algunes maneres particulars.
Mirant primer les seves limitacions, sabem molt bé que tenir una cobertura del 100% no garanteix que el Codi estigui lliure d’errors, ni tampoc garanteix que tots els requisits s’hagin cobert en el codi, és a dir, malgrat una cobertura del Codi del 100%, estem és molt probable que tinguin errors al codi, la raó és que la cobertura no garanteix que s'hagin provat tots els escenaris.
A més, si s’han omès els requisits mentre s’escriu el codi, no hi ha cap assignació de requisits amb el codi que es tingui en compte com a part de la cobertura del codi.
Dit això, no podem negar que quan fem servir la cobertura del codi com a mètriques, ens dóna una idea de si hem cobert els requisits bàsics per provar cada línia del nostre codi. Aquest percentatge de cobertura ens dóna una idea de quantes parts del nostre codi s’executen amb les nostres proves unitàries.
Sabem quina quantitat del nostre codi no seria executat. Al seu torn, això ens ajuda a decidir quant calen més proves unitàries i per a quines parts del codi.
Per tant, podem concloure que tenir una cobertura deficient ens dóna una idea de la ineficàcia de les proves unitàries. Al mateix temps, garantir una cobertura del 100% no és una garantia per a un codi lliure de defectes. Per tant, cal tenir un enfocament equilibrat on no posem èmfasi en la importància d’orientar-nos a un percentatge elevat de cobertura de codi.
Q # 4) Com puc millorar la cobertura del meu codi?
Resposta: L'informe de cobertura del codi que proporcionen eines de cobertura com JaCoCo, Istanbul, etc. mostra les àrees que estan cobertes per les proves i també aquelles que quedarien sense provar.
En conèixer les parts del codi que no s’han provat, les proves es poden escriure manualment o mitjançant qualsevol eina d’automatització per cobrir les àrees que d’una altra manera quedarien sense provar i, per tant, augmentarien la cobertura del codi.
Una cosa important a tenir en compte aquí és que, tot i que podem escriure centenars de línies de codi per provar una funció en codi, però la cobertura pot ser molt menor. El motiu és que aprofundir massa per provar una part de l’enorme codi no ajudarà a augmentar la cobertura del codi.
Per tant, si l'objectiu és augmentar la cobertura, cal tenir cura de cobrir totes les funcions, condicions i bucles en lloc de submergir-se en una sola funció i escriure grans proves per a aquesta funció.
Conclusió
Un producte de programari d’alta qualitat és el que es requereix en el món d’internet ràpid.
Garantir un programari de bona qualitat no només és responsabilitat d’un enginyer de control de qualitat, sinó que també és responsabilitat del desenvolupador. Per tant, la cobertura del codi és molt útil a l’hora de lliurar un producte de qualitat a l’equip de control de qualitat per part dels desenvolupadors.
Aquest tutorial explica tot sobre la cobertura del codi i els seus usos. També vam aprofundir una mica en la comprensió de la diferència entre la cobertura del codi i la cobertura de les proves. A més d’això, hem entès les metodologies utilitzades juntament amb diverses eines de cobertura de codi.
Els avantatges i els inconvenients es van informar aquí. Finalment, hem rebutjat alguns dels mites i preguntes més freqüents relacionades amb la cobertura del codi
Bona lectura !!
Lectura recomanada
- 15 eines principals de cobertura de codi (per a Java, JavaScript, C ++, C #, PHP)
- 15 millors eines JAVA per al desenvolupament, compilació, perfils, cobertura de codi i revisió
- C # Funcions / Mètodes Tutorial amb exemples de codi
- Tutorial de maneig d'excepcions C # amb exemples de codi
- Tutorial SVN de tortuga: revisions al dipòsit de codis
- Tutorial de longitud de matriu de Java amb exemples de codi
- Tutorial AWS CodeBuild: extracció de codi de Maven Build
- Tutorial SVN: Gestió del codi font mitjançant Subversion