JUnit Cazuri de testare @Before @BeforeClass Adnotare

JUnit este cea mai populară unitate Testarea cadru în Java. Este recomandat în mod explicit pentru Testarea unității. JUnit nu necesită server pentru testarea aplicației web, ceea ce face procesul de testare rapid.

JUnit framework permite, de asemenea, generarea rapidă și ușoară de cazuri de testare și date de testare. The org.Junit pachetul constă din multe interfețe și clase pentru JUnit Testare cum ar fi Test, Assert, After, Before etc.

Ce este dispozitivul de testare

Înainte de a înțelege ce este un dispozitiv de testare, să studiem codul de mai jos

Acest cod este conceput pentru a executa două cazuri de testare pe un fișier simplu.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Puține probleme aici

Codul nu este citit
Codul nu este ușor de întreținut.
Când suita de teste este complexă, codul poate conține probleme logice.

Comparați același cod folosind JUnit

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

Codul mult mai ușor de citit și de întreținut. Structura de cod de mai sus este a Dispozitiv de testare.

Un dispozitiv de testare este un context în care a JUnit Caz de testare aleargă. De obicei, dispozitivele de testare includ:

Obiecte sau resurse care sunt disponibile pentru orice caz de testare.
Activități necesare care pun la dispoziție aceste obiecte/resurse.
Aceste activități sunt
1. alocare (configurarea)
2. dezalocare (dărâma).

Configurare și demontare

De obicei, există unele sarcini repetate care trebuie făcute înainte de fiecare caz de testare. Exemplu: creați o conexiune la baza de date.
De asemenea, la sfârșitul fiecărui caz de testare, pot exista unele sarcini repetate. Exemplu: pentru a curăța odată ce execuția testului s-a încheiat.
JUnit oferă adnotări care ajută la configurare și demontare. Se asigură că resursele sunt eliberate, iar sistemul de testare este într-o stare pregătită pentru următorul caz de testare.

Acestea JUnit adnotările sunt discutate mai jos -

Configurarea

@Inainte de adnotare în JUnit este utilizat pe o metodă care conține Java cod de rulat înainte de fiecare caz de testare. adică rulează înainte de fiecare execuție de test.

Demontare (indiferent de verdict)

@După adnotarea este utilizată pe o metodă care conține cod java pentru a rula după fiecare caz de testare. Aceste metode se vor rula chiar dacă în cazul de testare sunt aruncate excepții sau în cazul eșecurilor de afirmare.

Notă:

Este permis să existe orice număr de adnotări enumerate mai sus.
Toate metodele adnotate cu @Inainte de in JUnit vor rula înainte de fiecare caz de testare, dar pot rula în orice ordine.
Puteți moșteni metodele @Before și @After dintr-o super clasă, Execuția este după cum urmează: Este un proces de execuție standard în JUnit.

Executați JUnit Metodele @Before din superclasă
Executați metodele @Before din această clasă
Executați o metodă @Test în această clasă
Executați metodele @After din această clasă
Executați metodele @After în superclasă

Exemplu: Crearea unei clase cu fișier ca dispozitiv de testare

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

În exemplul de mai sus, lanțul de execuție va fi după cum urmează:

createOutputFile()
testFile1()
deleteOutputFile()
createOutputFile()
testFile2()
deleteOutputFile()

Presupunere:

testFile1() rulează înainte de testFile2() – ceea ce nu este garantat.

Configurare o singură dată

Este posibil să rulați o metodă o singură dată pentru întreaga clasă de testare înainte ca oricare dintre teste să fie executat și înainte de orice @Inainte de metoda(e).
„O singură configurare” sunt utile pentru pornirea serverelor, deschiderea comunicațiilor etc. Închiderea și redeschiderea resurselor pentru fiecare test necesită mult timp.
Acest lucru se poate face folosind adnotarea @Înainte de curs in JUnit.

@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }

Dărâmați o singură dată

Similar cu configurarea o singură dată , este disponibilă și o metodă de curățare o singură dată. Se rulează după toate metodele de caz de testare și @După adnotările au fost executate.
Este util pentru oprirea serverelor, închiderea legăturilor de comunicare etc.
Acest lucru se poate face folosind @După clasa adnotare

 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }

JUnit Suite de testare

Dacă dorim să executăm mai multe teste într-o ordine specificată, se poate face combinând toate testele într-un singur loc. Acest loc se numește suite de testare. Mai multe detalii despre cum să executați suitele de testare și despre cum sunt utilizate în JUnit va fi acoperit în acest sens tutorial.

Junit Test Runner

JUnit oferă un instrument pentru executarea cazurilor dumneavoastră de testare.

JUnitNucleu clasa este folosită pentru a executa aceste teste.
O metodă numită runClass furnizate de către org.junit.runner.JUnitNucleu, este folosit pentru a rula una sau mai multe clase de testare.
Tipul de returnare al acestei metode este Rezultat obiect (org.junit.runner.Rezultat), care este folosit pentru a accesa informații despre teste. Consultați următorul exemplu de cod pentru mai multă claritate.

public class Test {				
			public static void main(String[] args) {									
       		Result result = JUnitCore.runClasses(CreateAndSetName.class);					
			for (Failure failure : result.getFailures()) {							
         		System.out.println(failure.toString());					
      }		
      System.out.println(result.wasSuccessful());					
   }		
}

În codul de mai sus, obiectul „rezultat” este procesat pentru a obține eșecuri și rezultate de succes ale cazurilor de testare pe care le executăm.

Prenumele JUnit program

Cunoștințe corecte despre SDLC, programarea java și elementele de bază ale testare software procesul ajută la înțelegere JUnit programul.

Să înțelegem Testarea unitară folosind un exemplu real. Trebuie să creăm o clasă de testare cu o metodă de testare adnotată cu @Test după cum se arată mai jos:

MyFirstClassTest.java

package guru99.JUnit;		

import static org.JUnit.Assert.*;				

import org.JUnit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}

TestRunner.java

Pentru a executa metoda noastră de testare (mai sus), trebuie să creăm un runner de testare. În runnerul de testare trebuie să adăugăm clasa de test ca parametru în JUnitMetoda runclasses() a lui Core. Acesta va returna rezultatul testului, în funcție de dacă testul a fost promovat sau eșuat.

Pentru mai multe detalii despre acest lucru vezi codul de mai jos:

package guru99.JUnit;		

import org.JUnit.runner.JUnitCore;		
import org.JUnit.runner.Result;		
import org.JUnit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
            Result result = JUnitCore.runClasses(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}

producție

Odată TestRunner.java execută metodele noastre de testare, obținem rezultate ca eșuate sau trecute. Vă rugăm să găsiți mai jos explicația rezultatului:

În acest exemplu, după executare MyFirstClassTest.java , testul este trecut și rezultatul este verde.
Dacă ar fi eșuat, ar fi trebuit să arate rezultatul ca roșu, iar eșecul poate fi observat în urma eșecului. Vezi mai jos JUnit gui :

Rezumat

JUnit este un cadru care acceptă mai multe adnotări pentru a identifica o metodă care conține un test.
JUnit oferă o adnotare numită @Test, care spune JUnit că metoda public void în care este utilizată poate rula ca un caz de testare.
Un dispozitiv de testare este un context în care rulează un caz de testare
Pentru a executa mai multe teste într-o ordine specificată, se poate face combinând toate testele într-un singur loc. Acest loc se numește suite de testare.
JUnit oferă un instrument pentru executarea testelor în care putem rula cazurile noastre de testare denumite Test Runner.