Démarrer avec Junit

Attraper l’exception attendue

Il est possible d’attraper facilement l’exception sans aucun bloc try catch.

public class ListTest {
  private final List<Object> list = new ArrayList<>();

  @Test(expected = IndexOutOfBoundsException.class)
  public void testIndexOutOfBoundsException() {
    list.get(0);
  }
}

L’exemple ci-dessus devrait suffire pour des cas plus simples, lorsque vous ne voulez/n’avez pas besoin de vérifier le message porté par l’exception levée.

Si vous souhaitez vérifier les informations sur l’exception, vous pouvez utiliser le bloc try/catch :

@Test
public void testIndexOutOfBoundsException() {
    try {
        list.get(0);
        Assert.fail("Should throw IndexOutOfBoundException");
    } catch (IndexOutOfBoundsException ex) {
        Assert.assertEquals("Index: 0, Size: 0", ex.getMessage());
    }
}

Pour cet exemple, vous devez être conscient de toujours ajouter Assert.fail() pour vous assurer que le test échouera si aucune exception n’est levée.

Pour les cas plus élaborés, JUnit a le [ExpectedException @Rule][1], qui peut également tester ces informations et est utilisé comme suit :

public class SimpleExpectedExceptionTest {
     @Rule
     public ExpectedException expectedException = ExpectedException.none();

     @Test
     public void throwsNothing() {
         // no exception expected, none thrown: passes.
     }

     @Test
     public void throwsExceptionWithSpecificType() {
         expectedException.expect(NullPointerException.class);

         throw new NullPointerException();
     }

     @Test
     public void throwsExceptionWithSpecificTypeAndMessage() {
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Wanted a donut.");

         throw new IllegalArgumentException("Wanted a donut.");
     }
}

Tester les exceptions dans JUnit5

Pour obtenir la même chose dans JUnit 5, vous utilisez un [mécanisme entièrement nouveau][2] :

La méthode testée

public class Calculator {
    public double divide(double a, double b) {
        if (b == 0.0) {
            throw new IllegalArgumentException("Divider must not be 0");
        }
        return a/b;
    }
}

La méthode test

public class CalculatorTest {
    @Test
    void triangularMinus5() { // The test method does not have to be public in JUnit5
        Calculator calc = new Calculator();

        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class, 
            () -> calculator.divide(42.0, 0.0));
        // If the exception has not been thrown, the above test has failed.

        // And now you may further inspect the returned exception...
        // ...e.g. like this:
        assertEquals("Divider must not be 0", thrown.getMessage());
}

[1] : http://junit.org/junit4/javadoc/4.12/org/junit/rules/ExpectedException.html [2] : http://junit.org/junit5/docs/current/user-guide/#writing-tests-assertions

Ignorer les tests

Pour ignorer un test, ajoutez simplement l’annotation @Ignore au test et fournissez éventuellement un paramètre à l’annotation avec la raison.

@Ignore("Calculator add not implemented yet.")
@Test
public void testPlus() {
    assertEquals(5, calculator.add(2,3));
}

Par rapport au fait de commenter le test ou de supprimer l’annotation @Test, le testeur signalera toujours ce test et notera qu’il a été ignoré.

Il est également possible d’ignorer conditionnellement un cas de test en utilisant les hypothèses JUnit. Un exemple de cas d’utilisation serait d’exécuter le cas de test uniquement après qu’un certain bogue ait été corrigé par un développeur. Exemple:

import org.junit.Assume;
import org.junit.Assert;
...

@Test 
public void testForBug1234() {

    Assume.assumeTrue(isBugFixed(1234));//will not run this test until the bug 1234 is fixed

    Assert.assertEquals(5, calculator.add(2,3));
}

L’exécuteur par défaut traite les tests avec des hypothèses défaillantes comme ignorés. Il est possible que d’autres coureurs se comportent différemment, par ex. traitez-les comme passés.

JUnit - Exemples d’annotations de base

Voici quelques annotations JUnit de base que vous devez comprendre : ================================================= =========

@BeforeClass – Run once before any of the test methods in the class, public static void 
@AfterClass – Run once after all the tests in the class has been run, public static void
@Before – Run before @Test, public void
@After – Run after @Test, public void
@Test – This is the test method to run, public void

Installation ou configuration

Puisque JUnit est une bibliothèque Java, tout ce que vous avez à faire pour l’installer est d’ajouter quelques fichiers JAR dans le chemin de classe de votre projet Java et vous êtes prêt à partir.

Vous pouvez télécharger ces deux fichiers JAR manuellement : junit.jar & hamcrest-core.jar.

Si vous utilisez Maven, vous pouvez simplement ajouter une dépendance dans votre pom.xml :

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

Ou si vous utilisez Gradle, ajoutez une dépendance dans votre build.gradle :

apply plugin: 'java'

dependencies {
    testCompile 'junit:junit:4.12'
}

Après cela, vous pouvez créer votre première classe de test :

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class MyTest {
    @Test
    public void onePlusOneShouldBeTwo() {
        int sum = 1 + 1;
        assertEquals(2, sum);
    }
}

et exécutez-le depuis la ligne de commande :

  • Windows java -cp .;junit-X.YY.jar;hamcrest-core-X.Y.jar org.junit.runner.JUnitCore MyTest
  • Linux ou OsX java -cp .:junit-X.YY.jar:hamcrest-core-X.Y.jar org.junit.runner.JUnitCore MyTest

ou avec Maven : mvn test

Exemple de test unitaire de base

Cet exemple est une configuration de base pour le test unitaire de StringBuilder.toString() à l’aide de junit.

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class StringBuilderTest {

    @Test
    public void stringBuilderAppendShouldConcatinate()  {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("String");
        stringBuilder.append("Builder");
        stringBuilder.append("Test");

        assertEquals("StringBuilderTest", stringBuilder.toString());
    }

}

@Avant après

Une méthode annotée avec @Before sera exécutée avant chaque exécution des méthodes @Test. De manière analogue, une méthode annotée @After est exécutée après chaque méthode @Test. Cela peut être utilisé pour configurer à plusieurs reprises un paramètre de test et nettoyer après chaque test. Ainsi, les tests sont indépendants et le code de préparation n’est pas copié dans la méthode @Test.

Exemple:

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class DemoTest {

    private List<Integer> list;

    @Before
    public void setUp() {
        list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(4);
        list.add(1);
        list.add(5);
        list.add(9);
    }

    @After
    public void tearDown() {
        list.clear();
    }

    @Test
    public void shouldBeOkToAlterTestData() {
        list.remove(0); // Remove first element of list.
        assertEquals(5, list.size()); // Size is down to five
    }

    @Test
    public void shouldBeIndependentOfOtherTests() {
        assertEquals(6, list.size());
    }
}

Les méthodes annotées avec @Before ou @After doivent être public void et avec zéro argument.