JUnit Testcases in Java: semplice JUnit 5.7.1 Hello World Tutorial con dettagli All in One

Pubblicato: 2019-10-30
java-junit-esempio

Cos'è JUnit?

JUnit è un framework open source semplice, potente per scrivere ed eseguire test ripetibili. Adoro i test di JUnit. Durante lo sviluppo del mio progetto Java, utilizzo ampiamente JUnit per la copertura del codice. È un'istanza dell'architettura xUnit per i framework di unit test.

Le caratteristiche di JUnit includono:

  1. Asserzioni per testare i risultati attesi
  2. Dispositivi di test per la condivisione di dati di test comuni
  3. Corridori di prova per le prove di corsa

In questo tutorial tratterò i punti 1 e 3. Hai bisogno di sotto le dipendenze Maven nel tuo progetto.

1
2
3
4
5
< dependency >
< groupId > junit < / groupId >
< artifactId > junit < / artifactId >
< version > 4.12 < / version >
< / dependency >

Iniziamo a scrivere il codice.

Passo 1

Crea il progetto CrunchifyJunitTest e specifica il pacchetto com.crunchify.junit . Ecco una struttura del pacchetto per una rapida consultazione.

Crunchify JUnit Project Struttura Eclipse

Passo 2

Fare clic con il pulsante destro del mouse su CrunchifyJunitTest => Nuova classe => CrunchifyJunitTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com . crunchify . junit ;
 
/**
* @author Crunchify
*
*/
 
import static org . junit . Assert . assertEquals ;
import org . junit . Test ;
 
public class CrunchifyJunitTest {
 
@ Test
public void testingCrunchifyAddition ( ) {
assertEquals ( "Here is test for Addition Result: " , 30 , addition ( 27 , 3 ) ) ;
}
 
@ Test
public void testingHelloWorld ( ) {
assertEquals ( "Here is test for Hello World String: " , "Hello + World" , helloWorld ( ) ) ;
}
 
public int addition ( int x , int y ) {
return x + y ;
}
 
public String helloWorld ( ) {
String helloWorld = "Hello +" + " World" ;
return helloWorld ;
}
}
 

Passaggio 3

Eclipse suggerirà e aggiungerà automaticamente la dipendenza org.junit.Test dopo aver digitato @Test .

Eclipse Test Dipendenza Maven

Passaggio 4

Per testare il tuo test JUnit

  • Fare clic con il tasto destro sulla classe
  • Fare clic su Esegui come
  • Clicca su JUnit Test

Dovresti vedere qualcosa del genere.

JUnit Test riuscito

Passaggio 5

Prova a cambiare il parametro del valore previsto del metodo da 30 => 300 e da Hello World => Hello -- World e prova di nuovo.

1
2
3
4
5
6
7
8
9
@ Test
public void testingCrunchifyAddition ( ) {
assertEquals ( "Here is test for Addition Result: " , 300 , addition ( 27 , 3 ) ) ;
}
 
@ Test
public void testingHelloWorld ( ) {
assertEquals ( "Here is test for Hello World String: " , "Hello -- World" , helloWorld ( ) ) ;
}
JUnit Test fallito - Crunchify Tips

Passaggio 6

Ora eseguiamo lo stesso test case via other java . Crea CrunchifyRunnerJUnit.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com . crunchify . junit ;
 
import org . junit . runner . JUnitCore ;
import org . junit . runner . Result ;
import org . junit . runner . notification . Failure ;
 
/**
* @author Crunchify
*
*/
 
public class CrunchifyRunnerJUnit {
 
public static void main ( String [ ] args ) {
Result result = JUnitCore . runClasses ( CrunchifyJunitTest . class ) ;
for ( Failure failure : result . getFailures ( ) ) {
System . out . println ( failure . toString ( ) ) ;
}
if ( result . wasSuccessful ( ) ) {
System . out . println ( "Both Tests finished successfully..." ) ;
}
}
}
 

Passaggio 7

Esegui CrunchifyRunnerJUnit.java come un'applicazione Java Application .

Passaggio 8

Nel caso del 1st code (param atteso corretto), dovresti vedere l'output in questo modo:

1
Both Tests finished successfully . . .

Passaggio 9

In caso di 2nd code (parametro previsto errato), dovresti vedere qualcosa del genere:

1
2
testingCrunchifyAddition ( com . crunchify . junit . CrunchifyJunitTest ) : Here is test for Addition Result :    expected : < 300 > but was : < 30 >
testingHelloWorld ( com . crunchify . junit . CrunchifyJunitTest ) : Here is test for Hello World String :    expected : < Hello [ -- ] World > but was : < Hello [ + ] World >

E sei a posto. Fatemi sapere se riscontrate problemi nell'esecuzione di questo codice.

JUnit Tutorial di Crunchify

Annotazione disponibile nel testcase JUnit:

Annotazione

Descrizione

@Test del metodo vuoto pubblico() L'annotazione @Test identifica che un metodo è un metodo di test.
@Prima del metodo vuoto pubblico() Eseguirà il metodo prima di ogni test. Questo metodo può preparare l'ambiente di test (ad es. leggere i dati di input, inizializzare la classe).
@Dopo il metodo vuoto pubblico() Eseguirà il metodo dopo ogni test. Questo metodo può ripulire l'ambiente di test (ad es. eliminare i dati temporanei, ripristinare le impostazioni predefinite).
@BeforeClass metodo void pubblico() Eseguirà il metodo una volta, prima dell'inizio di tutti i test. Questo può essere utilizzato per eseguire attività che richiedono molto tempo, ad esempio per connettersi a un database.
@AfterClass metodo vuoto pubblico() Eseguirà il metodo una volta, al termine di tutti i test. Questo può essere utilizzato per eseguire attività di pulizia, ad esempio per disconnettersi da un database.
@Ignorare Ignorerà il metodo di prova. Ciò è utile quando il codice sottostante è stato modificato e il test case non è stato ancora adattato. O se il tempo di esecuzione di questo test è troppo lungo per essere incluso.
@Test (previsto = Exception.class) Non riesce, se il metodo non genera l'eccezione denominata.
@Test(timeout=100) Non riesce se il metodo impiega più di 100 millisecondi.

Metodi di test di affermazione disponibili:

Dichiarazione

Descrizione

fallire (stringa) Lascia che il metodo fallisca. Potrebbe essere utilizzato per verificare che una determinata parte del codice non venga raggiunta. O avere un test fallito prima che il codice di test venga implementato.
assertTrue(true) / assertTrue(false) Sarà sempre vero/falso. Può essere utilizzato per predefinire il risultato di un test, se il test non è ancora stato implementato.
assertTrue([messaggio], condizione booleana) Verifica che la condizione booleana sia vera.
assertsEquals([Messaggio stringa], previsto, effettivo) Verifica che due valori siano uguali. Nota: per gli array viene verificato il riferimento non il contenuto degli array.
assertsEquals([Messaggio stringa], previsto, effettivo, tolleranza) Verifica che i valori float o double corrispondano. La tolleranza è il numero di decimali che deve essere lo stesso.
assertNull([messaggio], oggetto) Verifica che l'oggetto sia nullo.
assertNotNull([messaggio], oggetto) Verifica che l'oggetto non sia null.
assertSame([Stringa], previsto, effettivo) Verifica che entrambe le variabili facciano riferimento allo stesso oggetto.
assertNotSame([String], previsto, effettivo) Verifica che entrambe le variabili facciano riferimento a oggetti diversi.