La JUnit Assertions Class contiene una raccolta di metodi statici che consentono di condurre unit test. Le asserzioni sono una delle caratteristiche principali di JUnit. Questa classe ha oltre cinquanta metodi diversi. Alcuni test di classe Assertions falliranno se una condizione è vera, mentre altri falliranno se una condizione è falsa.
La classe Assertions ha anche molti metodi sovraccaricati. Ogni metodo di asserzione ha almeno due metodi sovraccaricati. Scopri alcuni dei metodi di classe Assertions più popolari e scopri come usarli per eseguire unit test.
Il metodo assertEquals
Il metodo JUnit 5 assertEquals ha più di dieci variazioni. Questo metodo è uno dei metodi di classe Assertions più popolari. Una variazione del metodo assertEquals accetta un valore atteso e la funzione che si desidera valutare (valore effettivo). Una seconda variante principale richiede un terzo argomento aggiuntivo. Questo è un messaggio di errore che verrà visualizzato se il Test unitario JUnit non riesce.
L'overload del metodo assertEquals si verifica con tipi di dati diversi. Alcuni metodi di overload assertEquals accettano un quarto argomento chiamato delta. Altre versioni sostituiscono la stringa di errore con un'interfaccia funzionale del Fornitore, sotto forma di a
espressione lambda.AssertionsMethods Classe Java
pacchetto com.programma;
pubblicoclasseAffermazioniMetodi{
pubblicostaticointquadrato(int num){
Restituzione numero * numero;
}
}
La classe Java AssertionsMethods sopra ha un unico metodo chiamato square. Il metodo square prende un valore intero e restituisce il suo quadrato. Per testare il metodo quadrato e qualsiasi metodo futuro della classe AssertionsMethods dovrai creare un test case JUnit.
Il caso di test di JUnit di AssertionsMethodsTest
pacchetto com.programma;importarestaticoorg.giugno.Asserire.assertEquals;
importarestaticoorg.giugno.Giove.api.Affermazioni.*;importareorg.giugno.Giove.api.Test;
classeAffermazioniMetodiTest{
@Test
vuototestSquare(){
assertEquals(25, Metodi di affermazione.quadrato(5));
assertEquals (36, AssertionMethods.square (6), "I tuoi valori quadrati non corrispondevano.");
assertEquals (49, AssertionMethods.square (7), () ->"I tuoi valori quadrati non corrispondevano.");
}
}
Il metodo testSquare() utilizza tre varianti di assertEquals() per testare il metodo square(). Ogni assertEquals() è un successo, poiché tutti i valori previsti corrispondono ai valori effettivi restituiti dal metodo square().
Il metodo assertNull
La classe JUnit Assertions ha esattamente tre metodi assertNull. Ciascuno di questi metodi accetta uno o più argomenti e afferma se l'oggetto specificato è nullo. Se un determinato oggetto non è nullo, il test avrà esito negativo.
@Test
pubblicovuototestStringValue(){
Corda StringValue = nullo;
assertNull (stringValue);
assertNull (stringValue, "Il valore della tua stringa non è nullo");
assertNull (stringValue, () ->"Il valore della tua stringa non è nullo");
}
Il primo metodo assertNull() prende un oggetto stringa e controlla se è nullo. Il secondo metodo assertNull() accetta un oggetto stringa e un messaggio stringa da visualizzare se il test fallisce. Il terzo e ultimo metodo assertNull() prende l'oggetto che si desidera valutare e un'interfaccia funzionale del fornitore.
Nel test case sopra, l'interfaccia del fornitore funge da destinazione di assegnazione per un'espressione lambda. L'espressione lambda genera un messaggio di errore se il test ha esito negativo.
Il metodo assertTrue
Il metodo assertTrue() ha sei varianti. Ogni metodo afferma se una determinata condizione è vera. Se una condizione assertTrue() è falsa, il test avrà esito negativo.
@Test
vuototestEvenNumbers(){
int num1 = 10;
int num2 = 16;
int num3 = 26;
assertTrue (num1 < num2);
assertTrue (num3 > num2, "La tua condizione non è vera.");
assertTrue (num1 < num3, () ->" La tua condizione non è vera.");
assertTrue(() -> num1%2 == 0);
assertTrue(() -> num2%2 == 0, "Il tuo valore non è un numero pari.");
assertTrue(() -> num3%2 == 0, () ->"Il tuo valore non è un numero pari.");
}
Il metodo testEvenNumbers() mostra come utilizzare tutti e sei i metodi assertTrue(). Tutti i metodi precedenti sono veri, pertanto questo unit test viene eseguito senza errori o errori.
- assertTrue (condizione booleana): questo metodo prende una condizione booleana e afferma se è vera. L'esempio di questo metodo nel codice precedente afferma se il primo valore intero è minore del secondo.
- assertTrue (condizione booleana, messaggio String): questo metodo richiede una condizione booleana da testare e una stringa da visualizzare se è falsa.
- assertTrue (condizione booleana, fornitore
messageSupplier): questo metodo accetta un'interfaccia funzionale booleana e una Supplier, come espressione lambda. Il fornitore del messaggio contiene una stringa da visualizzare se la condizione booleana è falsa. - assertTrue (BooleanSupplier booleanSupplier): questo metodo accetta un'interfaccia funzionale BooleanSupplier, sotto forma di un'espressione lambda che restituisce true o false. L'esempio di questo metodo nel codice usa un'espressione lambda. Verifica il resto del primo intero diviso per due per determinare se è pari o dispari.
- assertTrue (BooleanSupplier booleanSupplier, String message): questo metodo accetta un'interfaccia funzionale BooleanSupplier sotto forma di un'espressione lambda. Ci vuole anche un messaggio di stringa da stampare se BooleanSupier non è vero.
- assertTrue (BooleanSupplier booleanSupplier, Supplier
messageSupplier): questo metodo richiede un'interfaccia funzionale BooleanSupplier per asserire. Richiede anche un'interfaccia funzionale del fornitore, che è un'espressione lambda che stamperà un valore stringa se il test ha esito negativo.
Il metodo assertFalse
Il metodo assertFalse() è l'opposto del metodo assertTrue(). Questo metodo valuta una determinata condizione per vedere se è falsa. Se una determinata condizione è vera, il test assertFalse() avrà esito negativo. Il metodo assertFalse() ha anche sei variazioni che accettano gli stessi argomenti delle loro controparti assertTrue().
@Test
vuototestNotEvenNumbers(){
int num1 = 11;
int num2 = 17;
int num3 = 27;
assertFalse (num2 < num1);
assertFalse (num2 > num3, " La tua condizione non è falsa.");
assertFalse (num3 < num1, () ->" La tua condizione non è falsa.");
assertFalse(() -> num1%2 == 0);
assertFalse(() -> num2%2 == 0, "Il tuo valore è un numero pari.");
assertFalse(() -> num3%2 == 0, () ->"Il tuo valore è un numero pari.");
}
I sei metodi assertFalse() nel metodo testNotEvenNumbers() risultano tutti false, il che significa che i test assertFalse() hanno esito positivo.
I vantaggi del test unitario
Il test unitario è parte integrante del processo di sviluppo del software. I grandi progetti software falliscono per vari motivi, dai team che ci lavorano agli approcci di sviluppo.
Lo scopo del test unitario è eliminare i guasti del software fornendo un rilevamento precoce degli errori. Ciò richiede ai team di sviluppare specifiche chiare, migliorare la progettazione del software attraverso la documentazione degli errori e fornire supporto per la manutenzione del software.
Il test unitario non è l'unico approccio di test del software che dovresti utilizzare nel ciclo di vita dello sviluppo, è solo un ottimo punto di partenza.
