JUnit Casi di test @Before @BeforeClass Annotazione

JUnit è l'unità più popolare Testing quadro dentro Java. È esplicitamente consigliato per Test unitari. JUnit non richiede un server per testare l'applicazione web, il che rende veloce il processo di test.

JUnit framework consente inoltre la generazione rapida e semplice di casi di test e dati di test. IL org.Giugno Il pacchetto è costituito da molte interfacce e classi per JUnit Test come Test, Assert, Dopo, Prima, ecc.

Cos'è il dispositivo di prova

Prima di capire cos'è un dispositivo di prova, studiamo il codice seguente

Questo codice è progettato per eseguire due casi di test su un file semplice.

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(); 
}

Pochi problemi qui

Il codice non è leggibile
Il codice non è facile da mantenere.
Quando la suite di test è complessa, il codice potrebbe contenere problemi logici.

Confronta lo stesso codice utilizzando 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
    }
}

Il codice è molto più leggibile e gestibile. La struttura del codice sopra è a Dispositivo di prova.

Un dispositivo di prova è un contesto in cui a JUnit Test Case corre. In genere, le apparecchiature di prova includono:

Oggetti o risorse disponibili per qualsiasi caso di test.
Attività richieste che rendono disponibili questi oggetti/risorse.
Queste attività sono
1. allocazione (setup)
2. deallocazione (demolire).

Installazione e smontaggio

Di solito, ci sono alcune attività ripetute che devono essere eseguite prima di ogni caso di test. Esempio: creare una connessione al database.
Allo stesso modo, alla fine di ogni caso di test potrebbero esserci delle attività ripetute. Esempio: per ripulire una volta terminata l'esecuzione del test.
JUnit fornisce annotazioni che aiutano nella configurazione e nello smontaggio. Garantisce che le risorse vengano rilasciate e che il sistema di test sia pronto per il prossimo test case.

Alcuni degli JUnit le annotazioni sono discusse di seguito-

Impostare

@Prima annotazione in JUnit viene utilizzato su un metodo contenente Java codice da eseguire prima di ogni caso di test. cioè viene eseguito prima di ogni esecuzione del test.

Smontaggio (indipendentemente dal verdetto)

@Dopo l'annotazione viene utilizzata su un metodo contenente codice Java da eseguire dopo ogni caso di test. Questi metodi verranno eseguiti anche se vengono generate eccezioni nel caso di test o in caso di errori di asserzione.

Nota:

È consentito avere un numero qualsiasi di annotazioni elencate sopra.
Tutti i metodi annotati con @Prima in JUnit verranno eseguiti prima di ogni caso di test, ma possono essere eseguiti in qualsiasi ordine.
Puoi ereditare i metodi @Before e @After da una super classe, l'esecuzione è la seguente: È un processo di esecuzione standard in JUnit.

Eseguire il JUnit Metodi @Before nella superclasse
Esegui i metodi @Before in questa classe
Esegui un metodo @Test in questa classe
Esegui i metodi @After in questa classe
Esegui i metodi @After nella superclasse

Esempio: creazione di una classe con file come dispositivo di prova

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
    }
}

Nell'esempio sopra la catena di esecuzione sarà la seguente:

creaOutputFile()
testFile1()
deleteOutputFile()
creaOutputFile()
testFile2()
deleteOutputFile()

Assunzione:

testFile1() viene eseguito prima di testFile2()– il che non è garantito.

Configurazione una sola volta

È possibile eseguire un metodo solo una volta per l'intera classe di test prima che venga eseguito qualsiasi test e prima di qualsiasi altro @Prima metodo/i.
La configurazione "una sola volta" è utile per avviare server, aprire comunicazioni, ecc. Chiudere e riaprire le risorse per ciascun test richiede molto tempo.
Questo può essere fatto utilizzando l'annotazione @Prima della lezione in JUnit.

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

Demolire una sola volta

Simile alla configurazione una tantum, è disponibile anche un metodo di pulizia una tantum. Funziona dopo tutti i metodi del caso di test e @Dopo le annotazioni sono state eseguite.
È utile per arrestare server, chiudere collegamenti di comunicazione, ecc.
Questo può essere fatto usando il @Dopo la lezione annotazione

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

JUnit Suite di prova

Se vogliamo eseguire più test in un ordine specifico, possiamo farlo combinando tutti i test in un unico posto. Questo posto è chiamato test suite. Maggiori dettagli su come eseguire test suite e come vengono utilizzati in JUnit sarà trattato in questo lezione.

Corridore di prova Junit

JUnit fornisce uno strumento per l'esecuzione dei casi di test.

JUnitNucleo viene utilizzata per eseguire questi test.
Un metodo chiamato runClasses fornito da org.junit.runner.JUnitNucleo, viene utilizzato per eseguire una o più classi di test.
Il tipo restituito di questo metodo è il Risultato oggetto (org.junit.runner.Risultato), che viene utilizzato per accedere alle informazioni sui test. Per maggiore chiarezza, vedere il seguente esempio di codice.

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());					
   }		
}

Nel codice sopra l'oggetto "risultato" viene elaborato per ottenere fallimenti e risultati positivi dei casi di test che stiamo eseguendo.

Nome JUnit Programma

Discreta conoscenza di SDLC, programmazione Java e nozioni di base test del software processo aiuta nella comprensione JUnit .

Comprendiamo il test unitario utilizzando un esempio dal vivo. Dobbiamo creare una classe di test con un metodo di test annotato con @Test come indicato di seguito:

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

Per eseguire il nostro metodo di test (sopra), dobbiamo creare un test runner. Nel test runner dobbiamo aggiungere la classe test come parametro in JUnitIl metodo runclasses() di Core. Restituirà il risultato del test, a seconda che il test sia stato superato o meno.

Per maggiori dettagli vedere il codice qui sotto:

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());							
   }		
}

Uscita

Quando TestRunner.java esegue i nostri metodi di test, otteniamo un output come fallito o superato. Di seguito è riportata la spiegazione dell'output:

In questo esempio, dopo l'esecuzione MyFirstClassTest.java , il test è superato e il risultato è in verde.
Se avesse fallito, avrebbe dovuto mostrare il risultato in rosso e l'errore può essere osservato nella traccia degli errori. Vedi sotto JUnit gui:

Sommario

JUnit è un framework che supporta diverse annotazioni per identificare un metodo che contiene un test.
JUnit fornisce un'annotazione chiamata @Test, che racconta il JUnit che il metodo public void in cui viene utilizzato può essere eseguito come caso di test.
Un test fixture è un contesto in cui viene eseguito un test case
Per eseguire più test in un ordine specifico, è possibile farlo combinando tutti i test in un unico posto. Questo posto è chiamato "test suite".
JUnit fornisce uno strumento per l'esecuzione dei test in cui possiamo eseguire i nostri casi di test denominati Test Runner.

Potrebbe piacerti: