junit Tutoriel
Commencer avec junit
Recherche…
Remarques
JUnit est un framework simple pour écrire des tests répétables pour le langage de programmation Java . C'est une instance de l'architecture xUnit pour les frameworks de tests unitaires.
Les principales caractéristiques comprennent:
- Assertions , qui vous permettent de personnaliser la façon de tester les valeurs dans vos tests
- Testeurs qui vous permettent de spécifier comment exécuter les tests dans votre classe
- Des règles qui vous permettent de modifier de manière flexible le comportement des tests dans votre classe
- Suites , qui vous permettent de construire ensemble une suite de tests de différentes classes
Extension utile pour JUnit:
Versions
Version | Date de sortie |
---|---|
JUnit 5 Jalon 2 | 2016-07-23 |
JUnit 5 Jalon 1 | 2016-07-07 |
JUnit 4.12 | 2016-04-18 |
JUnit 4.11 | 2012-11-14 |
JUnit 4.10 | 2011-09-28 |
JUnit 4.9 | 2011-08-22 |
JUnit 4.8 | 2009-12-01 |
JUnit 4.7 | 2009-07-28 |
JUnit 4.6 | 2009-04-14 |
Installation ou configuration
Comme JUnit est une bibliothèque Java, tout ce que vous avez à faire pour l’installer est d’ajouter quelques fichiers JAR dans classpath 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 l'exécuter à partir de la ligne de commande:
- Windows
java -cp .;junit-X.YY.jar;hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
- Linux ou OsX
java -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
-cpjava -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
ou avec Maven: mvn test
Exemple de test élémentaire
Cet exemple est une configuration de base pour désinstaller le StringBuilder.toString () en utilisant 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
. @After
méthode analogue à @After
annotée est exécutée après chaque méthode @Test
. Cela peut être utilisé pour configurer plusieurs fois un paramètre de test et nettoyer après chaque test. Les tests sont donc 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 sans argument.
Catch exception prévue
Il est possible d'attraper facilement l'exception sans try catch
bloquer le bloc.
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 les cas plus simples, lorsque vous ne voulez / devez pas vérifier le message porté par l'exception déclenchée.
Si vous souhaitez vérifier les informations sur les exceptions, 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 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 la @Rule
ExpectedException
@Rule
, qui peut également tester cette information et est utilisée 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.");
}
}
Test des exceptions dans JUnit5
Pour obtenir la même chose dans JUnit 5, vous utilisez un mécanisme complètement nouveau :
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 de 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());
}
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 commentaire du test ou à la suppression de l’annotation @Test
, le @Test
test continuera à signaler ce test et notera qu’il a été ignoré.
Il est également possible d'ignorer un scénario de test de manière conditionnelle 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 bogue donné a é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));
}
Le runner par défaut traite les tests avec des hypothèses défaillantes comme étant ignorés. Il est possible que d'autres coureurs se comportent différemment, par exemple, les traitent comme réussis.
JUnit - Exemples d'annotation de base
Voici quelques annotations de base sur JUnit 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