Testfall är de villkor som ska testas när programvaran skapas. Innan vi skriver testfall i Java måste vi förstå vad testfall är. Det här avsnittet kommer att täcka en kort introduktion av testfall och sedan hur vi kan skriva in testfall Java .
Vad är testfall
Testfall är uppsättningen villkor som testas av en mjukvarutestare för den utvecklade applikationen. Testaren kontrollerar och utvärderar om den byggda mjukvaran uppfyller kundens alla krav. Om någon bugg eller fel hittas, informerar testaren utvecklingsteamet. Behovet av att bygga testfall och utföra testning är att verifiera att alla kundens behov är uppfyllda och att inga buggar finns i programvaran.
Till exempel: För en inloggningsmodul skulle testaren göra vissa följande testfall:
- Kontrollera att inloggningssidan består av textfält för användarnamn och lösenord och en inloggningsknapp.
- Verifiera vid lyckad inloggning, omdirigeras användaren till startsidan.
- Verifiera att användaren lyckades logga in genom att ange ett giltigt användarnamn och lösenord.
- Verifiera användarens misslyckade inloggning genom att ange ett giltigt användarnamn och ogiltigt lösenord.
- Kontrollera att användarens lösenord förvaras i krypterad form i databasen och så vidare.
Med dessa kan det finnas enligt testfall som en testare kan tänka sig, och när alla testfall är godkända är det bara den byggda mjukvaran som överlämnas till kunden.
För att veta mer om testfall, besök https://www.javatpoint.com/test-case.
Hur man skapar testfall i Java
Java är ett objektorienterat programmeringsspråk, och att bygga ett Java-projekt innebär att skapa massor av klasser, var och en med vissa metoder. För att bygga ett bra projekt/applikation behöver vi testa projektet och kontrollera om applikationen uppfyller alla krav. I Java spelar klasser och metoder en avgörande roll, och därför måste vi testa de klasser och metoder, som tillsammans kallas en Enhet , och det kommer behovet av att utföra Enhetstestning för dem. Så för att utföra enhetstestning i Java finns det flera testramverk. En sådan berömd ram är JUnit som är ett ramverk för att utföra enhetstestning. För att kunna utföra Junit-testning behöver vi skapa testfallen och testa projektet mot varje testfall och fastställa resultatet.
För att förstå hur man skapar testfall, låt oss skapa en enkel klass och undersöka den.
Låt oss skapa en klass DemoClass i Eclipse där vi har utfört en enkel additionsmetod genom att följa stegen nedan:
1) Öppna Eclipse IDE och skapa en ny Maven Projektera genom att klicka på Arkiv> Nytt> Annat... och då Välj en guide dialogrutan öppnas. Under Trollkarlar , du får se Maven repository, klicka på rullgardinsmenyn, klicka på Maven-projektet , och klicka sedan på Nästa . En ögonblicksbild visas nedan:
2) Välj 'Skapa ett enkelt projekt', eller så kan du också välja arketyp. Här har vi gjort ett enkelt projekt, så vi har valt alternativet 'Skapa ett enkelt projekt' och klickar sedan på Nästa, som du kan se i ögonblicksbilden nedan:
3) Nu kan du se Nytt Maven-projekt dialogrutan öppnas där vi måste tillhandahålla Grupp-ID och Artefakt-ID genom att följa:
Grupp-ID: Det är det unika namnet som hjälper till att identifiera en projektgrupp från en annan. Den följer Java-namnregelkonventionen, och därför måste den tillhandahållas som com.example.javatpoint eller någon annan.
Artefakt-id: Det är det unika namnet som ges till projektet vi ska skapa. Så för vårt projekt har vi tillhandahållit följande grupp-ID och artefakt-ID (dvs. projektnamnet), som du kan se i ögonblicksbilden nedan:
4) Klicka på Avsluta , och vårt Maven-projekt kommer att skapas med vissa filer där huvudfilen är xml Fil som innehåller alla detaljer om det skapade projektet.
5) Inom projektnamnet kommer du att se vissa repositories, gör ett högerklicka på src/main/java arkiv, klicka på Nytt > Klass , och skapa en Java klass . Här har vi skapat java , där vi har implementerat en enkel metod för att lägga till två tal. Koden är som följer:
public class DemoClass { public int sum(int i, int j) { return i+j; } Kodavsnittet visas nedan:
6) Nu har vi implementerat en klass, och det är dags att testa den, och för det måste vi använda Junit . Så, flytta till src/test/java mapp och högerklicka på den. Klicka på Nytt > Junit Test Case .
Och skapa ett JUnit-testfall enligt namnregelkonventionerna.
Klicka sedan på Avsluta . JUnit-testfallet kommer att skapas. Här har vi skapat JUnit-testfallet som TestDemoClass.java , och vi fick följande utdataskärm som täcker koden nedan:
import static org. junit.Assert.*; import org.junit.Test; public class TestDemoClass { @Test public void test() { fail('Not yet implemented'); } } Kodavsnittet visas nedan:
Här har vi använt testet New Junit 4. För att testa en klass eller metod måste vi använda testannoteringarna, och här har vi @Testa anteckning före testa () metod.
schakal vs varg
Obs: Vi har tagit ett exempelprojekt som kan testas manuellt, men när man gör ett stort projekt kan det bestå av många klasser med många metoder. Att kontrollera och testa alla dessa manuellt kanske inte är flexibelt, och förändringar i en klass kommer definitivt att påverka de andra klasserna. Därmed kommer rollen av automationstestning, det vill säga Junit-testning.
7) Skapa ett objekt av DemoClass inom TestDemoClass och vi måste testa belopp metod och för det har vi skapat följande testfallskod:
public class TestDemoClass { DemoClass obj=new DemoClass(); @Test public void testSum() { assertEquals(25,obj.sum(10, 15)); } } Kodavsnittet visas nedan:
8) Användningen av assertEquals(expectedVal, calculatedVal) Metoden används för att bestämma statusen för ett testfall, om det är underkänt eller godkänt. För att köra/köra ett testfall, högerklicka på koden och sedan Kör som > Junit Test .
9) Vi har experimenterat med följande testfall:
Testfall 1: Vi har skapat ett testfall där vi har testat om vi får respektive summa eller inte när vi tillhandahåller två värden. Om inte kommer testfallet att misslyckas, men för ovanstående värden fick vi följande utdata:
Därför gick vårt testfall framgångsrikt, vilket indikeras av grön symbol.
Testfall 2: Om vi skickar samma kod för de beräknade parametrarna (10, 15) men det förväntade värdet som 100 och har följande värden att testa, får vi vårt testfall misslyckats. Koden är som:
public class TestDemoClass { DemoClass obj=new DemoClass(); @Test public void testSum() { assertEquals(100,obj.sum(10, 15)); } } Kodavsnittet visas nedan:
Så vi fick vårt testfall misslyckats, vilket betyder att vår kod är korrekt, och den indikeras av Röd signal, som du kan se i utdraget nedan:
Testfall 3: Om vi skickar ett negativt och ett positivt värde för de beräknade parametrarna som (-5, 8), och förväntat parametervärde som 3 , får vi vårt testfall godkänt, som du kan se i utdraget nedan:
Men om vi klarar (5, -8) som beräknat värde och förväntat värde som 3, skulle testfallet misslyckas definitivt.
Testfall 4: Om vi skickar båda negativa värden för den beräknade parametern som (-10,-15) och förväntat parametervärde som -25 , får vi vårt testfall godkänt, som du kan se i utdraget nedan:
Men om vi klarar det förväntade värdet som 25 kommer testfallet definitivt att misslyckas. Låt oss se i utdraget nedan:
På detta sätt kan vi tänka på och skapa testfallen enligt vår tanke-, bedömnings- och testförmåga. Förutom exemplet som förklaras ovan, arbetar en mjukvarutestare med mycket stora applikationer för att testa dem och skapa vissa testfall och testa dem. För att registrera alla testfall använder de sig av excel-arket och undersöker om deras skapade testfall uppfyller kundens krav eller har några buggar. En mjukvarutestare skapar och skriver testfallen genom att tänka sig själv som en normal användare, och så undersöker applikationen/mjukvaran.