Junit Assert & AssertEquals avec l'exemple

Qu’est-ce que Junit Assert ?

La méthode `assert` permet de déterminer si un cas de test a réussi ou échoué. Elle est fournie par la classe `org.junit.Assert`, qui étend la classe `java.lang.Object`.

Il existe différents types d'assertions, comme les assertions booléennes, nulles, identiques, etc.

JUnit fournit une classe nommée Assert, qui propose un ensemble de méthodes d'assertion utiles pour écrire des cas de test et détecter les échecs de test.

Les méthodes assert sont fournies par la classe org.junit.Assert, qui étend le java.lang.Object classe.

JUnit Méthodes d'assertion

Boolean

Si vous souhaitez tester les conditions booléennes (vrai ou faux), vous pouvez utiliser les méthodes d'assertion suivantes :

1. assertTrue (condition)
2. assertFalse (condition)

Ici, la condition est une valeur booléenne.

Objet nul

Si vous souhaitez vérifier la valeur initiale d'un objet/variable, vous disposez des méthodes suivantes :

1. assertNull (objet)
2. assertNotNull (objet)

Ici, l'objet est un Java objet, par exemple assertNull (réel);

Identique

Si vous souhaitez vérifier si les objets sont identiques (c'est-à-dire comparer deux références au même objet), utilisez la méthode suivante : Java objet) ou différent :

1. assertSame(attendu, réel) — La fonction renverra vrai si attendu == réel.
2. assertNotSame (attendu, réel)

Affirmer est égal

Si vous souhaitez tester l'égalité de deux objets, vous disposez de la méthode suivante :

• assertEquals (attendu, réel)

Il retournera vrai si attendu.égal(réel) renvoie vrai.

Affirmer que le tableau est égal

Si vous souhaitez tester l'égalité de tableaux, vous disposez de la méthode suivante :

• assertArrayEquals (attendu, réel)

La méthode ci-dessus doit être utilisée si les tableaux ont la même longueur. Pour chaque valeur valide de i, vous pouvez le vérifier comme indiqué ci-dessous :

• assertEquals(expected[i], actual[i])
• assertArrayEquals(expected[i], actual[i])

Message d'échec

Si vous souhaitez générer une erreur d'assertion, vous avez échouer()ce qui aboutit toujours à un verdict d'échec.

• échouer(message);

Vous pouvez avoir une méthode d'assertion avec un élément supplémentaire Chaîne le paramètre en premier paramètre. Cette chaîne sera ajoutée au message d'erreur si l'assertion échoue. Par exemple, échec(message) peut s'écrire:

• assertEquals(message, attendu, réel)

JUnit affirmerÉgal

Vous avez assertEquals(a, b), qui repose sur la équivaut à () méthode de la classe Object.

• Ici, il sera évalué comme a.égale(b).
• Ici, la classe testée est utilisée pour déterminer une relation d’égalité appropriée.
• Si une classe ne remplace pas le équivaut à () méthode de Sujet classe, elle adoptera le comportement par défaut de la équivaut à () méthode, c'est-à-dire identité de l'objet.

If a et b sont des primitifs tels que octet, int, booléen, etc., alors ce qui suit sera fait pour assertEquals(a, b) :

a et b seront convertis en leur type d'objet wrapper équivalent (Octet, Entier, Booléen, etc.), puis a.égale(b) sera évalué.

Par exemple, considérons les chaînes de caractères mentionnées ci-dessous qui ont les mêmes valeurs ; testons cela à l’aide de assertEquals :

String obj1 = "Junit";
String obj2 = "Junit";
assertEquals(obj1, obj2);

L'instruction assert ci-dessus renverra vrai car obj1.equals(obj2) renvoie vrai.

Assertions à virgule flottante

Lorsque vous souhaitez comparer des types à virgule flottante (par exemple, double or flotter), vous avez besoin d'un paramètre obligatoire supplémentaire, delta, afin d'éviter les problèmes liés aux erreurs d'arrondi lors des comparaisons de nombres à virgule flottante.

L'assertion s'évalue comme indiqué ci-dessous :

• Math.abs(attendu – réel) <= delta

Par exemple :

assertEquals(aDoubleLa valeur, une autreDoubleValeur, 0.001)

JUnit Exemple d'affirmation

L'exemple ci-dessous montre comment affirmer une condition en utilisant JUnit affirmer des méthodes.

Créons une classe de test simple nommée Junit4AssertionTest.java et une classe de testeurs TestRunner.java.

Vous allez créer quelques variables et des instructions assert importantes dans JUnit.

Dans cet exemple, vous exécuterez notre classe de test à l'aide de TestRunner.java.

Étape 1) Créons une classe qui couvre toutes les méthodes importantes des instructions assert. JUnit:

Junit4AssertionTest.java

package guru99.junit;

import static org.junit.Assert.*;
import org.junit.Test;

public class Junit4AssertionTest {

    @Test
    public void testAssert() {

        // Variable declaration
        String string1 = "Junit";
        String string2 = "Junit";
        String string3 = "test";
        String string4 = "test";
        String string5 = null;
        int variable1 = 1;
        int variable2 = 2;
        int[] airethematicArrary1 = { 1, 2, 3 };
        int[] airethematicArrary2 = { 1, 2, 3 };

        // Assert statements
        assertEquals(string1, string2);
        assertSame(string3, string4);
        assertNotSame(string1, string3);
        assertNotNull(string1);
        assertNull(string5);
        assertTrue(variable1 < variable2);
        assertArrayEquals(airethematicArrary1, airethematicArrary2);
    }
}

Étape 2) Vous devez créer une classe d'exécution de tests pour exécuter la classe ci-dessus :

TestRunner.java

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(Junit4AssertionTest.class);
        for (Failure failure : result.getFailures()) {
            System.out.println(failure.toString());
        }
        System.out.println("Result==" + result.wasSuccessful());
    }
}

Étape 3) Analysons étape par étape le résultat attendu. Examinons chaque instruction assert une par une :

1. assertEquals(string1, string2);

Comparez maintenant string1="Junit" avec string2="Junit" à l'aide de la méthode equals de la classe Object. Remplacez la méthode assertEquals par la méthode java.lang.Object.equals() :

string1.equals(string2) => renvoie vrai

Donc assertEquals(string1, string2) renverra oui.

2. assertSame(chaîne3, chaîne4);

La fonction « assertSame() » permet de vérifier que deux objets font référence au même objet. Puisque string3 = « test » et string4 = « test », string3 et string4 sont du même type ; par conséquent, assertSame(string3, string4) renverra vrai. oui.

3. assertNotSame(chaîne1, chaîne3);

La fonction « assertNotSame() » permet de vérifier que deux objets ne font pas référence au même objet. Puisque string1="Junit" et string3="test", string1 et string3 sont de types différents, assertNotSame(string1, string3) renverra une valeur. oui.

4. assertNotNull(string1);

La fonction « assertNotNull() » permet de vérifier qu'un objet n'est pas nul. Puisque string1 = « Junit », qui est une valeur non nulle, assertNotNull(string1) renverra vrai. oui.

5. assertNull(string5);

La fonction « assertNull() » permet de vérifier si un objet est nul. Puisque string5=null, qui est une valeur nulle, assertNull(string5) renverra oui.

6. assertTrue(variable1 < variable2);

La fonction « assertTrue() » permet de vérifier qu'une condition est vraie. Puisque variable1=1 et variable2=2, ce qui indique que la condition variable1 < variable2 est vraie, assertTrue(variable1 < variable2) renverra oui.

7. assertArrayEquals(airethematicArrary1, airethematicArrary2);

La fonction « assertArrayEquals() » permet de vérifier que le tableau attendu et le tableau résultant sont égaux. Le type du tableau peut être `int`, `long`, `short`, `char`, `byte` ou `java.lang.Object`. Puisque `airethematicArrary1 = { 1, 2, 3 }` et `airethematicArrary2 = { 1, 2, 3 }`, ce qui indique que les deux tableaux sont égaux, `assertArrayEquals(airethematicArrary1, airethematicArrary2)` renverra `true`. oui.

Puisque les sept déclarations d'affirmation de Junit4AssertionTest.java La classe renvoie true ; lorsque vous exécutez le test assert class, le test sera réussi (voir le résultat ci-dessous).

Étape 4) Faites un clic droit sur Junit4AssertionTest.java et cliquez sur Exécuter en tant que -> JUnit. Vous verrez le résultat comme indiqué ci-dessous :

Le résultat ci-dessus indique un test réussi, comme prévu.

FAQ