Introduktion om JUnit-kommentarer
JUnit är ett av de mest kraftfulla, Java-baserade och open source-testramarna tillgängliga utan kostnad på marknaden. Det hjälper till att skapa en snabb och upprättande av testfall och testa ärenden i enlighet med kraven med hjälp av kommentarer. Anteckningar ger i princip extra information om klasserna och metoderna som används i Java-koden. Det hjälper till att utföra testning av varje enhetskomponent, oavsett om det är metoder, klasser, paket och variabler. Det används ofta för enhetstestning av applikationer. Den senaste uppgraderingen av JUnit är JUnit5. Det stöder Selenium webbdrivrutin för automatiseringstest av webb- och mobilapplikationer. org. Junit är paketet som innehåller alla gränssnitt och klasser för testning genom JUnit.
JUnit-kommentarer med exempel
Nedan ges några av JUnit-anteckningarna:
1. @ Före
Det finns scenarier när vissa testfall eller testdata måste skapas innan verkliga testfall genomförs. I så fall kom @För annoteringar in i bilden. Om du kommenterar alla offentliga metoder med denna kommentar kan koden / metoden köras före varje faktisk @testmetod. I fallet med arv kallas först tidigare metoder för superklass och sedan @ före metoder i den aktuella klassen.
2. @Efter
Det är precis motsatsen till @Fore annotation. Det används i de fall då vissa åtgärder måste utföras som att frigöra resurser, städa upp minne, skriva ut något på konsolen efter genomförandet av @ testmetoden (efter genomförandet av varje testfall). Det är en viktig punkt som bör noteras för @Efter en kommentar är att den kommer att köras även om @test eller @ tidigare metoderna kastar ett undantag. När det gäller förhållande mellan underklass och superklass utförs @after-metoden i underklass / nuvarande klass före @after-metoden för superklass.
3. @BeforeClass
Den här kommentaren används i scenarierna när vissa åtgärder måste utföras innan ett testfall i en viss klass exekveras som att skapa en anslutning till databasen, skapa en post i en databas, post i loggarna etc. När @BeforeClass annotation används före någon metod, den metoden körs innan någon testmetod i en klass. Det fungerar på samma sätt som @Before-annotationen, den enda skillnaden är att @Before kör metoden före exekveringen av varje @testmetod medan @BeforeClass körs endast en gång, dvs innan någon @testmetod körs i en klass.
4. @AfterClass
Alla resurser som tilldelats i metoden @BeforeClass måste släppas efter genomförandet av alla @testmetoder i den aktuella klassen. Denna omfördelning av resurser eller alla viktiga uppgifter som ska göras efter genomförandet av hela klassen görs med @AfterClass-metoden. Enkelt uttryckt går @AfterClass-metoden efter att alla @testmetoder i den aktuella klassen har utförts. Det körs bara en gång. @AfterClass-metoder körs obligatoriskt även om @BeforeClass-metoderna kastar ett undantag.
Liksom @After-metoden är arbetet med @AfterClass-metoden lika, förutom att @After-metoden körs efter varje @testmetod i klassen medan @AfterClass-metoden körs en gång efter att alla @testmetoder i en klass har utförts.
5. @ Test
Den här anteckningen specificerar att den offentliga metoden enligt denna kommentar är en del av det huvudsakliga testfallet som måste genomföras. Metoden under @test definierar testfallet som godkänt eller misslyckat beroende på om något undantag / fel uppstår vid körning av det.
Det kan också användas på två sätt:
- @ Test (timeout = 500): Det tar parametern som timeout som accepterar värdena i millisekunder. Den anser att testfallet misslyckades när det tar längre tid än den förväntade tiden att köra och passera när det körs framgångsrikt inom den angivna tidsgränsen.
- @ Test (förväntat = Exception.class): Det finns situationer när vi vill ha några metoder för att kasta ett specifikt undantag. Testfallet misslyckas om metoden inte kastar något undantag eller ovan nämnda undantag.
6. @ Ignorera
Det finns scenarier när vi vill ignorera några testfall och inte vill köra dem. @ Ignorera hjälper till detsamma. Metoder under @Ignore-kommentarerna körs inte och ignoreras under körningen av koden. Till och med i rapporterna genererade av TestNG visar antalet testfall som ignoreras och antalet testfall passerade.
Exempel
Låt oss ta ett exempel på JUnit-kommentarer
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");
)
)
Produktion:
Fördelar med JUnit-kommentarer
Nedan ges några av fördelarna med JUnit-anteckningar:
- JUnit tillhandahåller ett enkelt sätt att utföra testfall på ett specifikt sätt i enlighet med användarens krav.
- Det är lätt att exekvera flera testfall parallellt med JUnit genom att kombinera dem i en testsvit.
- JUnit-anteckningar som används för att automatisera testfall i Selenium ger mycket detaljerad och interaktiv, grafisk rapport till användaren som också är mycket användarvänlig.
- JUnit tillåter att passera parametrarna i metoden på ett mycket enkelt sätt.
- JUnit-annotering hjälper till att utföra ren kodning, vilket är mycket lätt att förstå för både testare och programmerare.
Slutsats
Ovanstående förklaring beskriver tydligt vikten av JUnit-ramverket och ordningen i vilken olika anteckningar av JUnit åberopas. Det är mycket viktigt att förstå de olika anteckningarna innan du använder dem i ett program så att det inte skapar några problem i att kontrollera körningsflödet.
Rekommenderade artiklar
Detta är en guide till JUnit-kommentarer. Här diskuterar vi introduktionen och kommentarerna av JUnit med exempel som inkluderar @ Före, @ Efter, @ Test och @ Ignorera, etc. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -
- Enhetstestning
- Testning av vit låda
- Selenium Arkitektur
- Test sele