Introductie over JUnit-annotaties
JUnit is een van de krachtigste, op Java gebaseerde en open-source testframework dat kosteloos op de markt beschikbaar is. Het helpt bij het eenvoudig en snel maken van testcases en het uitvoeren van testcases volgens de vereisten met behulp van annotaties. Annotaties bieden in principe extra informatie over de klassen en de methoden die in de Java-code worden gebruikt. Het helpt bij het testen van elke afzonderlijke component, ongeacht of het methoden, klassen, pakketten en variabelen betreft. Het wordt vaak gebruikt voor het testen van applicaties door eenheden. De nieuwste upgrade van JUnit is JUnit5. Het ondersteunt het Selenium-webstuurprogramma voor het testen van de automatisering van web- en mobiele applicaties. org. Junit is het pakket dat alle interfaces en klassen bevat voor testen via JUnit.
JUit Annotatie s met Voorbeeld
Hieronder worden enkele JUnit-annotaties gegeven:
1. @Voordat
Er zijn scenario's waarin sommige testgevallen of testgegevens moeten worden gemaakt voordat de daadwerkelijke testcase wordt uitgevoerd. In dat geval kwamen er annotaties in beeld. Door elke openbare methode met deze annotatie te annoteren, kan de code / methode worden uitgevoerd vóór elke daadwerkelijke @test-methode. In het geval van overerving worden eerst de @voor-methoden van de superklasse en vervolgens de @-vóór-methoden van de huidige klasse genoemd.
2. @Na
Het is precies het tegenovergestelde van @Voor annotatie. Het wordt gebruikt in de gevallen waarin sommige acties moeten worden uitgevoerd, zoals het vrijgeven van bronnen, het opruimen van geheugen, het afdrukken van alles op de console na de uitvoering van de methode @test (na de uitvoering van elke testcase). Er is een belangrijk punt dat moet worden opgemerkt voor @Na annotatie is dat het wordt uitgevoerd, zelfs in het geval dat de methoden @test of @before een uitzondering genereren. In het geval van een sub- en superklasserelatie wordt de @ after-methode van de subklasse / huidige klasse uitgevoerd vóór de @ after-methode van de superklasse.
3. @BeforeClass
Deze annotatie wordt gebruikt in de scenario's wanneer sommige acties moeten worden uitgevoerd voordat een testcase van een bepaalde klasse wordt uitgevoerd, zoals het maken van een verbinding met de database, het maken van een vermelding in een database, vermelding in de logboeken, enz. Wanneer @BeforeClass annotatie wordt gebruikt vóór elke methode, die methode wordt uitgevoerd vóór elke testmethode in een klasse. De werking ervan is vergelijkbaar met het enige verschil tussen @Voor annotatie, namelijk dat @Voor de methode uitvoert voorafgaand aan de uitvoering van elke @testmethode, terwijl @BeforeClass slechts één keer uitvoert, dat wil zeggen voorafgaand aan de uitvoering van een @testmethode in een Klasse.
4. @AfterClass
Alle bronnen die zijn toegewezen in de methode @BeforeClass moeten worden vrijgegeven nadat alle @test-methoden van de huidige klasse zijn uitgevoerd. Deze deallocatie van bronnen of elke belangrijke taak die moet worden uitgevoerd nadat de hele klasse is uitgevoerd, wordt uitgevoerd met de methode @AfterClass. In eenvoudige bewoordingen wordt de methode @AfterClass uitgevoerd nadat alle @test-methode van de huidige klasse is uitgevoerd. Het wordt slechts één keer uitgevoerd. @AfterClass-methoden worden verplicht uitgevoerd, zelfs als de @BeforeClass-methoden een uitzondering genereren.
Net als de methode @After, is de werking van de methode @AfterClass vergelijkbaar, behalve het feit dat de methode @After wordt uitgevoerd na elke @testmethode van de klasse, terwijl de methode @AfterClass wordt uitgevoerd nadat alle @testmethoden van een klasse zijn uitgevoerd.
5. @Test
Deze annotatie geeft aan dat de openbare methode onder deze annotatie deel uitmaakt van de belangrijkste testcase die moet worden uitgevoerd. De methode onder de @test definieert het testgeval als geslaagd of mislukt, afhankelijk van of er een uitzondering / fout optreedt bij het uitvoeren ervan.
Het kan ook op 2 manieren worden gebruikt:
- @Test (time-out = 500): het neemt de parameter als time-out die de waarden in milliseconden accepteert. Het beschouwt het testgeval als mislukt wanneer het langer duurt dan de verwachte tijd om uit te voeren en te slagen wanneer het succesvol binnen de gespecificeerde tijdslimiet wordt uitgevoerd.
- @Test (verwacht = Exception.class): Er zijn situaties waarin we bepaalde methoden een specifieke uitzondering willen geven. De testcase mislukt als de methode geen uitzondering of de bovengenoemde uitzondering oplevert.
6. @Ignore
Er zijn scenario's waarin we enkele testgevallen willen negeren en deze niet willen uitvoeren. @Ignore helpt hiervoor. Methoden onder de annotaties @Ignore worden niet uitgevoerd en worden genegeerd tijdens de uitvoering van de code. Zelfs in de rapporten die door TestNG zijn gegenereerd, wordt het aantal testgevallen weergegeven dat wordt genegeerd en het aantal testgevallen geslaagd.
Voorbeeld
Laten we een voorbeeld nemen van JUnit Annotations
package demo;
import org.junit.*;
public class JUnitAnnotationTest (
// Run once, before any @test method in the class are executed
@BeforeClass
public static void bClass() (
System.out.println("BeforeClass method is called”);
)
// Run once after all the @test methods of the class are executed
@AfterClass
public static void aClass() (
System.out.println("AfterClass method is called");
)
// Run before every @test method of a class is executed
@Before
public void bMethod() (
System.out.println("before method is called");
)
// Run after every @test method of class is executed
@After
public void aMethod() (
System.out.println("after method is called");
)
// Test method which has actual test case
@Test
public void testMethod() (
System.out.println("Test method is called");
)
)
Output:
Voordelen van JUnit-annotaties
Hieronder worden enkele voordelen van JUnit-annotaties gegeven:
- JUnit biedt een eenvoudige manier om de testgevallen op een specifieke manier uit te voeren volgens de eisen van de gebruiker.
- Het is gemakkelijk om de meerdere testgevallen parallel uit te voeren met behulp van de JUnit door ze te combineren in een testpakket.
- JUnit-annotaties die worden gebruikt voor het automatiseren van testcases in Selenium, bieden een zeer gedetailleerd en interactief grafisch rapport aan de gebruiker, dat ook zeer gebruiksvriendelijk is.
- JUnit maakt het mogelijk om de parameters in de methode op een zeer eenvoudige manier door te geven.
- JUnit annotatie helpt bij het uitvoeren van schone codering die zeer gemakkelijk te begrijpen is voor zowel testers als programmeurs.
Conclusie
De bovenstaande uitleg beschrijft duidelijk het belang van het JUnit-raamwerk en de volgorde waarin verschillende annotaties van JUnit worden ingeroepen. Het is erg belangrijk om de verschillende annotaties te begrijpen voordat u ze in een programma gebruikt, zodat er geen problemen ontstaan bij het regelen van de uitvoeringsstroom.
Aanbevolen artikelen
Dit is een gids voor JUnit-annotaties. Hier bespreken we de introductie en annotaties van JUnit met Voorbeeld, waaronder @ Before, @ After, @ Test en @Ignore, enz. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Testen van een eenheid
- White Box testen
- Selenium-architectuur
- Test harnas