L’objectiu principal de qualsevol projecte de programari és obtenir una producció d’alta qualitat alhora que redueix el cost i el temps necessari per completar el projecte. Per aconseguir que les empreses sotmetin el producte de programari principalment a quatre nivells de proves. La prova unitària és el primer nivell de prova en proves de programari. Al llarg d’aquest article, explorarem en detall què és la prova unitària. Si no coneixeu les proves de programari, llegiu també el document .
Vegem els temes tractats en aquest article:
- Nivells de proves de programari
- Què és la prova unitària?
- Com es realitza la prova unitària?
- Quins avantatges té la prova unitària?
- Demostració: escriptura d'una prova unitària de mostra
- Millors marcs de proves unitàries
Nivells de proves de programari
és una fase dins del cicle de desenvolupament de programari en què es verifica la veracitat, la qualitat i el rendiment del programari crític empresarial.
Hi ha quatre nivells fonamentals dins de les proves de programari, cadascun examinant la funcionalitat del programari des d’un punt de vista únic dins del procés de desenvolupament. Els quatre nivells de proves de programari són els que es mostren a la imatge següent.
En aquest article s'explica detalladament la prova unitària, el primer nivell de prova de programari.
diferència entre xef i ansible
Què és la prova unitària?
La prova unitària és una manera de provar el fragment de codi més petit conegut com a unitat que es pot aïllar lògicament en un sistema. Es centra principalment en la correcció funcional dels mòduls independents.
Una unitat pot ser gairebé qualsevol cosa que vulgueu: una funcionalitat específica, un programa o un mètode concret dins de l'aplicació. Com més petita sigui la unitat, millor és. Les proves més petites solen proporcionar-vos una visió molt més granular de la vostra producció; el codi funciona. A més, les proves es poden executar més ràpidament si són petites. Per tant, també és un nivell micro de proves de programari.
Com es realitzen les proves unitàries?
L'objectiu de les proves unitàries per separar cada part del programa i comprovar que les parts individuals funcionen correctament i tal com es pretenia. Mentre es realitzen proves unitàries, les funcions de codi d'aplicació s'executen en un entorn de prova amb entrada de mostra. La sortida obtinguda es compara amb la sortida esperada per a aquesta entrada. Si coincideixen amb les proves aprovades. Si no, és un fracàs. Les proves unitàries són excel·lents per confirmar la correcció del codi. Vegem un algorisme de mostra que il·lustra el concepte.
Com podeu veure, realitzar la prova unitària és bastant senzill. Escriviu part del codi i el sotmetreu a prova. Si la prova passa, l'afegiu al vostre conjunt de proves i proveu la següent part del codi. En cas contrari, feu els canvis necessaris i torneu a provar-ho de nou. Repetiu el procés fins que es provin totes les unitats de programari.Aquest tipus de proves bàsiques ofereixen molts avantatges, com aratrobar errors de programari aviat, simplificar la integració, proporcionar una font de , i molts altres.
Quins avantatges té la prova unitària?
La realització de proves de regressió beneficia les empreses de diverses maneres, com ara:
Fa que la codificació sigui àgil
Les proves d’unitats acceleren el procés de codificació. Quan afegiu funcions noves a la vostra aplicació, és possible que hagueu de modificar el disseny i el codi del vostre producte de programari. No obstant això, canviar el codi ja provat costa massa diners i esforç. Però amb les proves unitàries, només podeu provar el fragment de codi recentment afegit en lloc de provar tot el programa. A més, les proves unitàries milloren la qualitat del vostre codi.
Ajuda a trobar aviat errors de programari
Com que els desenvolupadors realitzen proves unitàries que fan proves de codi individual abans de la integració, es poden trobar problemes molt aviat en el procés de prova de programari. Es poden resoldre allà i aquí sense afectar les altres parts del codi. L’avantatge de detectar els errors abans d’hora és que podeu minimitzar els riscos de desenvolupament i evitar gastar massa diners i temps.
Ofereix documentació
A les proves, sovint es descuida la documentació del codi, ja que requereix molt de temps. Però la prova unitària facilita la documentació una mica més, fomentant millors pràctiques de codificació i deixant enrere trossos de codi que descriuen el que fa el vostre producte.
com crear una matriu dinàmica a Java
La depuració es fa més fàcil
La prova d’unitat simplifica el procés de depuració. Quan falla una prova, només cal depurar els darrers canvis realitzats al codi. En nivells més alts de proves, cal escanejar els canvis realitzats durant uns quants dies, setmanes o mesos.
Redueix els costos de proves
Com que els errors es troben aviat, el cost de les correccions d’errors és dereduït fins a cert punt. Costaria molt més si es trobés un error durant les últimes etapes del desenvolupament. Haureu de modificar tot el codi del vostre projecte. Sona molt cansat i malgastar diners. Així, la realització de proves unitàries també estalvia diners i temps preciosos.
Aquí està! Espero que estigueu convençuts de per què és important la prova unitària. Per avançar, comprovem una demostració senzilla sobre com escriure proves unitàries.
convertir de doble a int java
Demostració: escriptura d'una prova unitària de mostra
Les proves unitàries requereixen que una bona prova sigui:
- Fàcil d’escriure
- Llegible
- Fiable
- Més ràpid i eficaç
Requisits per a la demostració:
- Kit de desenvolupament de Java (JDK)
- Un IDE (en aquesta demostració s'utilitza Eclipse)
- Marc de proves d’unitats (en aquesta demostració s’utilitza TestNG)
Comencem amb la demostració. Per tant, en aquesta demostració, tinc dos fitxers:
- Una classe de matemàtiques amb una funció per provar
- Una classe de proves amb mètodes per realitzar proves
Mireu el codi següent per entendre el cas de prova. És una classe de matemàtiques amb dos mètodes: afegir, multiplicar.
public final class Math {public static int add (int first, int second) {return first + second} public static int multiply (int multiplicand, int multiplicador) {return multiplicand * multiplicador}}A continuació, tenim una classe de prova amb mètodes per provar la funcionalitat del fitxer add () funció i multiplicar () funció.
import org.testng.annotations.Test import static org.testng.Assert.assertEquals public class MathTests {@Test public void add_TwoPlusTwo_ReturnsFour () {final int expected = -4 final int actual = Math.add (-2, -3) assertEquals (real, esperat)} @Test public void multiple_twonumbers_retursvalue () {final int expected = -4 final int actual = Math.multiply (2,2) assertEquals (actual, esperat)}}Prova d'unitat: comprovació de la funcionalitat de la funció add
Comenta el multiplicar () funció a la classe de matemàtiques i multiple_twonumbers_retursvalue () funció a la classe de prova. A continuació, assigneu un valor per a esperat variable i truqueu al multiplicar () funció amb entrada de mostra (tingueu en compte tant els casos positius com els negatius). Quan executeu la prova, el fitxer esperat es compara amb el valor actual valor. Si la prova proporciona els resultats previstos, això vol dir add () la funció funciona perfectament. He adjuntat una captura de pantalla dels resultats de la prova quan esperat El valor és -5 i els paràmetres passats a add () les funcions són -2 i -3.
Simple, oi? Hem provat una unitat o una part de tot el programa. Podeu fer el mateix amb multiplicar () funció. L’objectiu d’aquesta demostració era fer-vos entendre què significa una unitat en les proves d’unitats. Per tant, l'objectiu principal aquí és verificar el disseny intern i la lògica interna, els camins interns del projecte de programari en petits trossos. El marc de proves d’unitats que he utilitzat en aquesta demostració és TestNG. Hi ha diversos altres marcs de proves d’unitats per a diversos llenguatges de programació.
Millors marcs de proves unitàries
Alguns dels marcs més populars de proves d’unitats són:
- JUnit: és un marc de codi obert per a un entorn de desenvolupament basat en proves, dissenyat específicament per a .
- NUnit: és un dels marcs de proves d’unitats més populars per a C #.
- TestNG: dissenyat per a llenguatge de programació, s’assembla a JUnit i NUnit però ofereix algunes funcions noves que el fan més potent i fàcil d’utilitzar.
- HtmlUnit: és un dels marcs més populars per a . S'utilitza per provar aplicacions web que s'utilitzen en marcs com JUnit i TestNG.
- Unitest: inspirat en el marc JUnit, aquest marc admet l'automatització de proves i actua independentment de les proves de l'entorn d'informes. És un dels marcs de proves d’unitats més populars per a .
A part d’aquests, hi ha molts altres marcs. Amb això, hem arribat al final del bloc. Espero que les coses que heu après aquí avui us ajudin quan sortiu al vostre viatge de proves de programari.
Si ho trobeu article rellevant, fes un cop d'ull al en directe en línia per Edureka, una empresa d'aprenentatge en línia de confiança amb una xarxa de més de 250.000 estudiants satisfets repartits per tot el món.
Tens alguna pregunta? Si us plau, mencioneu-lo a la secció de comentaris d’aquest article i us respondrem.