Het belangrijkste doel van elk softwareproject is om een output van hoge kwaliteit te krijgen en tegelijkertijd de kosten en de tijd die nodig zijn voor het voltooien van het project te verminderen. Om dat te bereiken onderwerpen bedrijven softwareproducten aan hoofdzakelijk vier testniveaus. Unittesten is het eerste testniveau in softwaretests. In dit artikel zullen we in detail onderzoeken welke unit-test is. Als u nieuw bent bij het testen van software, lees dan ook het .
Laten we eens kijken naar de onderwerpen die in dit artikel worden behandeld:
- Niveaus van softwaretests
- Wat is het testen van eenheden?
- Hoe voer je unit-tests uit?
- Wat zijn de voordelen van unit-testen?
- Demo: het schrijven van een voorbeeldeenheidstest
- Beste frameworks voor het testen van eenheden
Niveaus van softwaretests
is een fase binnen de softwareontwikkelingscyclus waarin bedrijfskritische software wordt geverifieerd op juistheid, kwaliteit en prestaties.
Er zijn vier fundamentele niveaus binnen softwaretests, die elk de softwarefunctionaliteit onderzoeken vanuit een uniek gezichtspunt binnen het ontwikkelingsproces. De vier niveaus van softwaretests zijn zoals weergegeven in de onderstaande afbeelding.
In dit artikel wordt het testen van eenheden, het eerste niveau van softwaretests, in detail uitgelegd.
hoe php windows te installeren
Wat is het testen van eenheden?
Unit testing is een manier om het kleinste stukje code te testen dat een eenheid die logisch geïsoleerd kunnen worden in een systeem. Het is vooral gericht op de functionele correctheid van stand-alone modules.
Een eenheid kan bijna alles zijn wat u maar wilt: een specifiek stuk functionaliteit, een programma of een bepaalde methode binnen de toepassing. Hoe kleiner de eenheid, hoe beter. Kleinere tests geven u meestal een veel gedetailleerder beeld van uw productie, de code presteert. Ook kunnen uw tests sneller worden uitgevoerd als ze klein zijn. Het is dus ook het microniveau van softwaretesten.
Hoe voer je unit-tests uit?
Het doel van unit testing is om elk onderdeel van het programma te scheiden en te testen of de individuele onderdelen correct en zoals bedoeld werken. Tijdens het uitvoeren van unit-tests worden toepassingscodefuncties uitgevoerd in een testomgeving met voorbeeldinvoer. De verkregen output wordt vervolgens vergeleken met de verwachte output voor die input. Als ze overeenkomen, slaagt de test. Zo niet, dan is het een mislukking. Unit-tests zijn geweldig om de juistheid van de code te bevestigen. Laten we eens kijken naar een voorbeeldalgoritme dat het concept illustreert.
Zoals u kunt zien, is het uitvoeren van de unit-test vrij eenvoudig. Je schrijft een deel van de code en onderwerpt deze aan tests. Als de test slaagt, voegt u deze toe aan uw testsuite en test u het volgende deel van de code. Anders brengt u de nodige wijzigingen aan en test u het opnieuw. Herhaal het proces totdat alle software-eenheden zijn getest.Dit type basistesten biedt veel voordelen, zoalsvroegtijdig softwarefouten opsporen, integratie vereenvoudigen, een bron van , en vele anderen.
Wat zijn de voordelen van unit-testen?
Het uitvoeren van regressietests biedt bedrijven voordelen op een aantal manieren, zoals:
Maakt coderen flexibel
Het testen van eenheden versnelt het coderingsproces. Wanneer u nieuwe functies aan uw toepassing toevoegt, moet u soms het ontwerp en de code van uw softwareproduct wijzigen. Het wijzigen van reeds geteste code kost echter te veel geld en moeite. Maar met unit-tests kunt u gewoon het nieuw toegevoegde stuk code testen in plaats van het hele programma te testen. Unit-tests verbeteren ook de kwaliteit van uw code.
Helpt bij het vroegtijdig opsporen van softwarefouten
Aangezien unit-tests worden uitgevoerd door ontwikkelaars die individuele code testen voordat ze worden geïntegreerd, kunnen problemen al heel vroeg in het softwaretestproces worden gevonden. Ze kunnen ter plekke worden opgelost zonder de andere delen van de code te beïnvloeden. Het voordeel van vroegtijdig opsporen van fouten is dat u ontwikkelingsrisico's kunt minimaliseren en te veel geld en tijd kunt vermijden.
Biedt documentatie
Bij het testen wordt codedocumentatie vaak verwaarloosd omdat het veel tijd kost. Maar het testen van eenheden maakt documentatie een beetje eenvoudiger door betere coderingspraktijken aan te moedigen en ook stukjes code achter te laten die beschrijven wat uw product doet.
Foutopsporing is eenvoudiger gemaakt
Het testen van eenheden vereenvoudigt het foutopsporingsproces. Als een test mislukt, hoeven alleen de laatste wijzigingen in de code te worden opgespoord. Bij hogere testniveaus moeten wijzigingen die in de loop van enkele dagen, weken of maanden zijn aangebracht, worden gescand.
Verlaagt testkosten
Omdat de bugs vroeg worden gevonden, zijn de kosten van bugfixesenigszins verminderd. Het zou veel meer kosten als er tijdens de latere ontwikkelingsstadia een bug wordt gevonden. U moet de volledige code van uw project wijzigen. Dat klinkt erg vermoeiend en geldverspilling. Het uitvoeren van unit-tests bespaart dus ook kostbare tijd en geld.
Daar ga je! Ik hoop dat u ervan overtuigd bent waarom het testen van eenheden belangrijk is. Laten we verder gaan en een eenvoudige demo bekijken over het schrijven van unit-tests.
Demo: het schrijven van een voorbeeldeenheidstest
Unit testen vereist dat een goede test moet zijn:
- Makkelijk te schrijven
- Leesbaar
- Betrouwbaar
- Sneller en efficiënter
Vereisten voor de demo:
- Java Development Kit (JDK)
- Een IDE (in deze demo wordt Eclipse gebruikt)
- Unit testing framework (in deze demo wordt TestNG gebruikt)
Laten we beginnen met de demo. Dus in deze demo heb ik twee bestanden:
- Een wiskundeklasse met een functie om te testen
- Een testklasse met methoden om tests uit te voeren
Bekijk de onderstaande code om de testcase te begrijpen. Het is een wiskundeles met twee methoden: optellen, vermenigvuldigen.
openbare laatste klasse Math {public static int add (int first, int second) {return first + second} public static int multiply (int multiplicand, int multiplier) {return multiplicand * multiplier}}Vervolgens hebben we een testklasse met methoden om de functionaliteit van het toevoegen() functie en vermenigvuldigen() functie.
import org.testng.annotations.Test import statische org.testng.Assert.assertEquals openbare klasse MathTests {@Test openbare leegte add_TwoPlusTwo_ReturnsFour () {final int verwacht = -4 final int actueel = Math.add (-2, -3) assertEquals (actual, verwacht)} @Test public void multiple_twonumbers_retursvalue () {final int verwacht = -4 final int actueel = Math.multiply (2,2) assertEquals (actueel, verwacht)}}Unit Test: functionaliteit van add-functie controleren
Reageer op het vermenigvuldigen() functie in Math-klasse en multiple_twonumbers_retursvalue () functie in de testklasse. Wijs vervolgens waarde toe aan de verwacht variabele en roep de vermenigvuldigen() functie met voorbeeldinvoer (beschouw zowel positieve als negatieve gevallen). Wanneer u de test uitvoert, wordt het verwacht waarde wordt vergeleken met de stroom waarde. Als de test de beoogde resultaten oplevert, betekent dit dat toevoegen() functie werkt perfect. Ik heb een screenshot van testresultaten bijgevoegd wanneer het verwacht waarde is -5 en de parameters worden doorgegeven aan toevoegen() functie zijn -2 en -3.
Simpel toch? We hebben een unit of een deel van het gehele programma getest. U kunt hetzelfde doen met vermenigvuldigen() functie. Het doel van deze demo was om u te laten begrijpen wat een eenheid betekent bij het testen van eenheden. Het belangrijkste doel van hier is dus om het interne ontwerp en de interne logica, interne paden van het softwareproject in kleine stukjes te verifiëren. Het framework voor het testen van eenheden dat ik in deze demo heb gebruikt, is TestNG. Er zijn verschillende andere frameworks voor het testen van eenheden voor verschillende programmeertalen.
Beste frameworks voor het testen van eenheden
Enkele van de populaire frameworks voor het testen van eenheden zijn:
- JUnit: het is een open-source framework voor een testgestuurde ontwikkelomgeving, speciaal ontworpen voor .
- NUnit: Het is een van de meest populaire frameworks voor unit-testing voor C #.
- TestNG: ontworpen voor programmeertaal, het lijkt op JUnit en NUnit, maar biedt enkele nieuwe functionaliteiten die het krachtiger en gemakkelijker te gebruiken maken.
- HtmlUnit: het is een van de meest populaire frameworks voor . Het wordt gebruikt voor het testen van webapplicaties die worden gebruikt binnen frameworks zoals JUnit en TestNG.
- Unitest: Geïnspireerd door het JUnit-framework, ondersteunt dit framework testautomatisering en werkt het onafhankelijk van de tests uit de rapportageomgeving. Het is een van de meest populaire frameworks voor unit-testing voor .
Afgezien hiervan zijn er nog veel andere frameworks. Hiermee zijn we aan het einde van de blog gekomen. Ik hoop dat de dingen die je hier vandaag hebt geleerd, je zullen helpen bij je reis naar het testen van software.
Als je dit hebt gevonden artikel relevant, bekijk de live-online door Edureka, een vertrouwd online leerbedrijf met een netwerk van meer dan 250.000 tevreden leerlingen verspreid over de hele wereld.
Heeft u een vraag voor ons? Vermeld het in het opmerkingengedeelte van dit artikel en we nemen contact met u op.