list junit annotations
Deze tutorial legt alles uit over JUnit-annotaties samen met een vergelijking van annotaties in JUnit 4 versus JUnit 5:
We hebben de verschillende manieren geleerd om JUnit-testcases uit te voeren en hebben in onze vorige tutorial gezien hoe we een testsuite kunnen maken en uitvoeren.
In deze tutorial maken we kennis met het prominente aspect van JUnit dat wordt genoemd Annotaties. Vanaf JUnit 4 zijn annotaties aanwezig en maken JUnit zeer eenvoudig, voordeliger en veel gebruiksvriendelijker in gebruik.
Annotaties is een Java API waarmee JVM het type methode kan herkennen dat is gedefinieerd in de testklasse. Er zijn vaak gebruikte annotaties voor het terugbellen van de levenscyclus.
Bezoek hier om JUnit vanaf het begin te leren.
Wat je leert:
JUnit-annotaties - JUnit 4 versus JUnit 5
Een testuitvoering doorloopt verschillende stadia van de levenscyclus, zoals hieronder weergegeven:
- Voordat u aan een test begint, moeten er bepaalde activiteiten worden uitgevoerd bij het begin van een les.
- Bepaalde andere activiteiten die moeten worden uitgevoerd voordat een testcase wordt uitgevoerd.
- Bepaalde activiteiten die moeten worden uitgevoerd na het uitvoeren van de test en
- Bepaalde activiteiten aan het einde van de uitvoering van alle tests in een klas.
Om er zeker van te zijn dat deze activiteiten worden uitgevoerd in elke fase van de Java-levenscyclus, moeten er bepaalde door de gebruiker gedefinieerde methoden of functies zijn die worden genoemd als ‘ methoden voor het terugbellen van de levenscyclus
Het gedrag van deze methoden voor het terugbellen van de levenscyclus wordt bepaald door de ingebouwde ‘ annotaties voor het terugbellen van de levenscyclus gebruikt in JUnit.
Voorbeeld: Laten we proberen het nog eenvoudiger te maken door deze call-back-methoden en annotaties voor de levenscyclus te relateren aan een voorbeeld van het testen van een koffieautomaat.
- Een methode machineReady () die controleert of er water, melk en koffiebonen beschikbaar zijn voordat de machine wordt ingeschakeld, kan nodig zijn.
- Een andere methode startMachine () die de machine inschakelt, plaatst mogelijk een nieuwe nieuwe kartonnen beker in de machine.
- Een testcase die de ‘ Heet water ()' optie.
- Een andere testcase die de ‘ Cappuccino ()' optie.
- Een andere testcase die de ‘ ExpressoCoffee ()' optie.
- Een andere methode ' throwCup () ”Die de gebruikte bekers in de prullenbak gooit.
- Een methode op klassenniveau ' throwTrashandSwitchOff () ”Gooit overlopende afvalvloeistof uit de bak in de bak en schakelt de machine uit.
Dus, in het bovenstaande voorbeeld, is hier hoe de levenscyclus van de test volgt:
- startMachine () wordt uitgevoerd voorafgaand aan elke testcase - Heet water Cappuccino () en ExpressoCoffee () loopt.
- Elk van deze testgevallen volgt ook de methode throwCup
- De methodes machineReady () en throwTrashandSwitchOff () zijn methoden op klassenniveau die slechts één keer voor een klasse worden uitgevoerd. De methode machineReady () wordt één keer uitgevoerd terwijl de klasse de uitvoering start. De methode throwTrashandSwitchOff () wordt eenmaal uitgevoerd nadat alle testgevallen volledig zijn uitgevoerd.
Nu rijst de vraag dat dit slechts Java-methoden zijn, en dan:
beste schoonmaaktool voor pc
- Hoe zullen we erop aandringen dat JVM wordt uitgevoerd machineReady () slechts één keer op klasniveau en throwTrashandSwitchOff () aan het einde van de klasse-uitvoering?
- Hoe gaan we JVM dat laten weten? startMachine () en throwCup () moet worden uitgevoerd voordat elke testcase wordt uitgevoerd en respectievelijk na voltooiing van elke testcase?
- Hoe kunnen we JVM laten identificeren dat de methoden Heet water Cappuccino () en ExpressoCoffee () moeten testcases worden uitgevoerd?
Antwoord: Het enige antwoord op de bovenstaande vragen is dat de callback-annotaties voor de levenscyclus alle vereiste magie doen.
(Laten we voorlopig aannemen dat we deze klasse maken in JUnit 4)
De annotaties van de levenscyclus - @BeforeClass, @AfterClass, @Before, @After, en @Test zijn de echte antwoorden op de bovenstaande drie vragen. We zijn er vrij zeker van dat u na het lezen van de onderstaande aanwijzingen duidelijk zult worden met annotaties voor het terugbellen van de levenscyclus en de bijbehorende workflow.
- Annoteer de methode machineReady () met @Voor klas en JVM zal het een keer laten draaien tijdens het begin van de les.
- Annoteer de methode afval gooien () met @Na de les en JVM zorgt ervoor dat het eenmaal aan het einde van de les wordt uitgevoerd.
- Annoteer de methode startMachine () met @Voordat en JVM zal het uitvoeren voordat elke testcase wordt uitgevoerd.
- Annoteer de methode throwCup () met @Na en JVM zal het uitvoeren na de uitvoering van elke testcase.
- Annoteer elk van deze methoden Heet water Cappuccino () en ExpressoCoffee () met @Test en JVM weet dat dit de kerntestgevallen zijn voor de JUnit-klasse die moet worden uitgevoerd.
Laten we snel eens kijken naar de JUnit lifecycle call-back annotaties voor JUnit 4 versus JUnit 5
JUNIT 4 ANNOTATIE | 5 JUNIT ANNOTATIE | |
---|---|---|
@RepeatedTest | 1.JUnit 5 ondersteunt herhaalde uitvoering van de testmethode voor een bepaald aantal keren met behulp van @RepeatedTest annotatie | |
@Voordat | @BeforeEach | |
@Na | @Na elke | |
@Voor klas | @Voor alles | |
@Na de les | @Ten slotte | |
@Test | @Test |
Opeenvolgende workflow van de levenscyclusannotaties
Hieronder is de sequentiële workflow van de annotaties van de levenscyclus voor JUnit 4 weergegeven:
- De methode geannoteerd met @BeforeClass wordt één keer uitgevoerd aan het begin van de klas.
- De methode geannoteerd met @Before wordt uitgevoerd voordat Testcase 1 begint.
- De methode Testcase1 geannoteerd met @Test is de testcase in de klas.
- De methode geannoteerd met @After wordt uitgevoerd nadat Testcase 1 de uitvoering heeft voltooid.
- De methode geannoteerd met @Before wordt uitgevoerd voordat Testcase 2 begint.
- De methode Testcase2 geannoteerd met @Test is de testcase in de klas.
- De methode geannoteerd met @After wordt uitgevoerd nadat Testcase 2 de uitvoering heeft voltooid.
- De methode geannoteerd met @AfterClass wordt eenmaal uitgevoerd aan het einde van de klas nadat zowel testcase 1 als 2 zijn uitgevoerd.
De opeenvolgende workflow van de annotaties van de levenscyclus voor JUnit 5 is als volgt:
- De methode geannoteerd met @BeforeAll wordt eenmaal uitgevoerd aan het begin van de klas.
- De methode geannoteerd met @BeforeEach wordt uitgevoerd voordat Testcase 1 begint.
- De methode Testcase1 geannoteerd met @Test is de testcase in de klas.
- De methode geannoteerd met @AfterEach wordt uitgevoerd nadat Testcase 1 de uitvoering heeft voltooid.
- De methode geannoteerd met @BeforeEach wordt uitgevoerd voordat Testcase 2 begint.
- De methode Testcase2 geannoteerd met @Test is de testcase in de klas.
- De methode geannoteerd met @AfterEach wordt uitgevoerd nadat Testcase 2 de uitvoering heeft voltooid.
- De methode geannoteerd met @AfterAll wordt eenmaal uitgevoerd aan het einde van de klas nadat zowel testcase 1 als 2 zijn uitgevoerd.
Uitwerking op elke annotatie
Laten we in dit gedeelte diep ingaan en een gedetailleerd begrip krijgen van wat elk van de terugbelannotaties voor levenscycli doet:
@Before (JUnit 4) / @ BeforeEach (JUnit 5):
- De geannoteerde methode wordt uitgevoerd vóór de uitvoering van elke testmethode in de testklasse.
- Deze annotatie kan worden gebruikt als u de resources of testgegevens wilt instellen net voor het starten van elke test.
- Bijvoorbeeld, als er 5 Testcases in een JUnit-testklasse zijn, wordt de methode geannoteerd met @ Before / @ BeforeEach 5 keer uitgevoerd voorafgaand aan elke uitvoering van de testcase.
@After (JUnit 4) / @ AfterEach (JUnit 5):
- De geannoteerde methode wordt uitgevoerd nadat elke testmethode in de testklasse is uitgevoerd.
- Deze annotatie kan worden gebruikt als u gebruikte bronnen of testgegevens wilt vrijgeven nadat elke testcase is uitgevoerd.
- Bijvoorbeeld, als er 5 Testcases in een JUnit-testklasse zijn, wordt de methode geannoteerd met @ After / @ AfterEach 5 keer uitgevoerd na de uitvoering van de testcases.
@BeforeClass (JUnit 4) / @ BeforeAll (JUnit 5):
- De geannoteerde methode wordt uitgevoerd voordat alle testmethoden in een testklasse zijn uitgevoerd.
- Deze annotatie kan worden gebruikt als u bronnen wilt instellen of gegevens wilt testen op klasniveau.
- Aangezien deze methode is geannoteerd met @ BeforeClass / @ BeforeAll wordt slechts één keer uitgevoerd voor een testklasse en de kopie van de methode wordt gedeeld met de klas, en de methode moet worden vermeld statisch.
- Bijvoorbeeld, als er 5 Testcases in een JUnit-testklasse zijn, wordt de methode geannoteerd met @ BeforeClass / @ BeforeAll eenmaal per testklasse uitgevoerd voordat een testcase wordt gestart.
@AfterClass (JUnit 4) / @ AfterAll (JUnit 5):
- De geannoteerde methode wordt uitgevoerd nadat alle testmethoden in een testklasse zijn uitgevoerd.
- Deze annotatie kan worden gebruikt als u de gebruikte bronnen of testgegevens op klasniveau wilt vrijgeven.
- Aangezien deze methode is geannoteerd met @ AfterClass / @ AfterAll wordt slechts één keer uitgevoerd voor een testklasse en de kopie van de methode wordt gedeeld met de klas, moet de methode worden vermeld statisch.
- Bijvoorbeeld, als er 5 Testcases in een JUnit-testklasse zijn, wordt de methode geannoteerd met @ AfterClass / @ AfterAll eenmaal per testklasse uitgevoerd nadat alle testcases volledig zijn uitgevoerd.
@Test (JUnit 4 & JUnit 5):
- De annotatie @Test is zowel voor JUnit 4 als voor JUnit 5 gebruikelijk. De geannoteerde methoden vertegenwoordigen de testgevallen in de klas.
- Er kunnen meerdere methoden zijn die elk zijn geannoteerd met @Test in een JUnit-klasse. Dit impliceert dat een klas meerdere testgevallen kan hebben.
- Er zijn verschillende attributen of parameters om te testen die kunnen worden doorgegeven. U kunt een geforceerde time-out toevoegen voor een testcase of een uitzondering toevoegen. Dit wordt in een aparte tutorial uitgebreid besproken.
- De geannoteerde methode kan niet privé of statisch zijn en kan geen waarde retourneren.
- De @Test-methode moet als openbaar worden gedeclareerd in JUnit 4, terwijl Junit 5 een testcase toestaat die is gedefinieerd zonder de toegangsmodificator ‘public’, aangezien het standaard ‘geen toegangsmodifier’ als ‘openbaar’ beschouwt.
Basis JUNIT-testvoorbeeld
Een basis JUNIT 4 voorbeeld voor annotaties @BeforeClass, @Before, @Test, @After en @AfterClass werd getoond door de code met zijn uitleg in onze eerdere tutorial over ‘Test Fixtures’.
Laten we naar de basis kijken JUnit 5 Programma om de werking van de terugbelannotaties van Lifecycle @BeforeAll, @BeforeEach, @Test, @AfterEach en @AfterAll te demonstreren.
Code voor JUnit5Program.java:
Bij uitvoering van het klassenbestand wordt het onderstaande resultaat weergegeven in het consolevenster.
Aanvullende annotaties - JUnit 4 versus JUnit 5
Er zijn veel aanvullende annotaties die voor specifieke doeleinden worden gebruikt. We zullen de lijst met annotaties voor JUnit 4 versus JUnit 5 en het doel ervan in het kort zien.
Er zal een gedetailleerde tutorial zijn over elk van deze annotaties in onze komende tutorials.
JUNIT 4 ANNOTATIE | 5 JUNIT ANNOTATIE | Beschrijving in het kort |
---|---|---|
@RTLnieuws | @TestMethodOrder & @Order | 1. Met deze annotaties kan de gebruiker de volgorde van uitvoering van de methoden binnen een testklasse kiezen |
@Rule & @ClassRule | @ExtendWith | 1. @Rule - De annotatie is een uitbreiding van de klasse TestRule die helpt bij het toepassen van bepaalde regels op de testgevallen. 2. Bijvoorbeeld: het aanmaken van een tijdelijke map voorafgaand aan de uitvoering van de testcase en het verwijderen van de map na uitvoering kan worden ingesteld via een regel. 3. @Rule is alleen beschikbaar in JUnit 4, die kan worden gebruikt in JUnit 5 Vintage, maar @ExtendWith biedt een nauwere functie voor JUnit 5 4. Evenzo kan een algemene time-out worden ingesteld met @Rule. |
NA | @TestFactory | 1. Deze annotatie wordt alleen ondersteund door JUnit 5 en helpt bij het maken van dynamische of runtime-tests. 2. Het retourneert een gegevensstroom als verzameling en kan geen callback-annotaties voor de levenscyclus gebruiken |
NA | @Genest | 1. Deze annotatie wordt alleen ondersteund door JUnit Jupiter 2. Het helpt ons geneste testgevallen te creëren. 3. Klasse 1 met testcase 1 kan bijvoorbeeld een @Nested Class 2 met testcase 2 hebben. Dit maakt testcase 2 een geneste testcase in testcase 1. Vandaar dat testcase 1 wordt uitgevoerd en testcase 2 wordt uitgevoerd. 4.Als de @Nested-annotatie niet wordt gebruikt, wordt de geneste klasse niet uitgevoerd. |
@Categorie | @Label | 1. Deze annotatie helpt bij het labelen en filteren van de tests 2.U kunt tests voor uitvoering opnemen of ze uitsluiten door te filteren op basis van de categorieën waarin ze vallen. |
@RunWith (Parameterized.class) @ Parameterized.Parameters | @ParameterizedTest en @ValueSource | 1. Deze annotatie wordt gebruikt om een methode met variaties in testgegevens meerdere keren uit te voeren. 2.JUnit 4 ondersteunt @RunWith en @Parameters terwijl JUnit 5 Jupiter @ParameterizedTest ondersteunt met @ValueSource |
@Weergavenaam | 1. Een door de gebruiker gedefinieerde naam kan worden gegeven aan een testmethode of -klasse voor weergavedoeleinden. | |
@TestInstance (LifeCycle.PER_CLASS) en @TestInstance (LifeCycle.PER_METHOD) | 1. JUnit 5 ondersteunt de configuratie van de levenscyclus van tests. 2. Zowel JUnit 4 als 5 volgen de standaard terugbellen van de levenscyclus per methode, terwijl configuratie per klasse ook mogelijk is. |
Referenties => JUnit 4 JUnit 5
Gevolgtrekking
- We leerden over de annotaties voor het terugbellen van de levenscyclus en de sequentiële workflow waarin de testmethoden worden uitgevoerd op basis van hun annotaties.
- We hebben de annotaties geleerd die worden gebruikt voor JUnit 4 en de annotaties voor JUnit 5.
- We hebben ook geleerd over aanvullende annotaties die JUnit 4 ondersteunt en die alleen JUnit 5 ondersteunen.
Bekijk hier de eenvoudige JUnit-trainingsserie.
Aanbevolen literatuur
- Wat is een JUnit-testopstelling: zelfstudie met JUnit 4-voorbeelden
- JUnit-tests: hoe u JUnit-testcases schrijft met voorbeelden
- JUnit-zelfstudie voor beginners - Wat is JUnit-testen
- Download, installeer en configureer JUnit in Eclipse
- Meerdere manieren om JUnit-tests uit te voeren
- Inleiding tot JUnit Framework en het gebruik ervan in Selenium Script - Selenium Tutorial # 11
- Covert List To Array en andere collecties in Java
- Java-lijstmethoden - lijst sorteren, bevat, lijst toevoegen, lijst verwijderen