JUnit Casi di test @Before @BeforeClass Annotazione

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

Migliori JUnit framework consente inoltre la generazione rapida e semplice di casi di test e dati di test. IL org.junit il pacchetto è costituito da molte interfacce e classi per JUnit test, come Test, Assert, After e Before. L'ampiezza JUnit La famiglia si costruisce sugli stessi elementi fondamentali.

Che cos'è un dispositivo di prova?

Prima di capire cos'è un test fixture, analizziamo 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 manutenibile. La struttura del codice sopra riportata è una 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à necessarie per rendere disponibili questi oggetti e risorse.
• Queste attività sono
  1. allocazione (setup)
  2. deallocazione (demolire).

Installazione e smontaggio

Gli impianti sono importanti perché JUnit esegue questi hook attorno a ogni test.

• 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 utili per la configurazione e la disattivazione. Garantisce il rilascio delle risorse e assicura che il sistema di test sia pronto per il caso di test successivo.

Alcuni degli JUnit Le annotazioni vengono discusse più avanti.

Impostare

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

Smontaggio (indipendentemente dal verdetto)

@Dopo l'annotazione viene utilizzata su un metodo contenente Java Codice 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.
• È possibile ereditare i metodi @Before e @After da una superclasse. L'esecuzione è la seguente, ed è un processo di esecuzione standard in JUnit.

1. Eseguire il JUnit Metodi @Before nella superclasse
2. Esegui i metodi @Before in questa classe
3. Esegui un metodo @Test in questa classe
4. Esegui i metodi @After in questa classe
5. Esegui i metodi @After nella superclasse

JUnit Nota del 5: queste annotazioni sono JUnit 4 (org.junit). JUnit 5 li hanno rinominati in org.junit.jupiter.api JUnit Il codice 4 riportato di seguito funziona ancora con il motore vintage.

Esempio: Creazione di una classe con file come fixture di test

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 precedente la catena di esecuzione sarà la seguente. Il diagramma tracun ciclo di creazione-test-eliminazione per ogni metodo di test.

1. creaOutputFile()
2. testFile1()
3. deleteOutputFile()
4. creaOutputFile()
5. testFile2()
6. deleteOutputFile()

Assunzione:

La funzione testFile1() viene eseguita 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 tantum" è utile per avviare i server, stabilire le comunicazioni e operazioni simili. Chiudere e riaprire le risorse per ogni 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	
 }	

Il metodo deve essere vuoto statico pubblico, perché JUnit viene chiamata prima che esista qualsiasi istanza di test.

Demolire una sola volta

• Analogamente alla configurazione una tantum, è disponibile anche un metodo di pulizia una tantum. Viene eseguito dopo tutti i metodi dei casi di test e @Dopo le annotazioni sono state eseguite.
• È utile per fermarsiping server e chiusura dei collegamenti di comunicazione.
• Questo può essere fatto usando il @Dopo la lezione annotazione.

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

JUnit Suite di prova

Una volta predisposti gli impianti, le classi di test correlate vengono solitamente raggruppate e avviate insieme.

Se vogliamo eseguire più test in un ordine specificato, possiamo farlo combinando tutti i test in un unico posto. Questo posto è chiamato suite di test. Maggiori dettagli su come eseguire le suite di test e su come vengono utilizzate in JUnit sono coperti in questo lezione.

JUnit Test Runner

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, consultare 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 riportato, l'oggetto "result" viene elaborato per ottenere i fallimenti e gli esiti positivi dei casi di test che stiamo eseguendo. Funzioni di supporto come assertEquals sollevare tali fallimenti, mentre @Ignorare salta un test.

JUnit Nota del 5: JUnitNucleo Europe è JUnit 4 corridori. JUnit 5 lo sostituisce con il JUnit Piattaforma Launcher API, normalmente avviata dall'IDE, Gradle o Maven Surefire.

Nome JUnit Programma

Buona conoscenza del ciclo di vita dello sviluppo del software (SDLC), Java programmazione e le basi della test del software il processo aiuta a comprendere un JUnit programma, così come sapere come test unitari differiscono dai test di integrazione.

Comprendiamo i test unitari usando un esempio pratico. 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 di test come parametro in JUnitIl metodo runClasses() di Core. Restituisce il risultato del test, a seconda che il test sia superato o fallito.

Per maggiori dettagli, consultare il codice seguente:

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 Eseguendo i nostri metodi di test, otteniamo un output che indica se il test è fallito o superato. Di seguito è riportata la spiegazione dell'output:

1. In questo esempio, dopo l'esecuzione MyFirstClassTest.javaIl test è superato e il risultato è in verde.
2. Se avesse fallito, avrebbe mostrato il risultato in rosso e il fallimento può essere osservato nel fallimento trace. Vedi il JUnit Interfaccia grafica (GUI) qui sotto:

DOMANDE FREQUENTI