Cours Java JUnit

Les tests unitaires avec JUnit 5
Achref El Mouelhi
Docteur de l’université d’Aix-Marseille

Chercheur en programmation par contrainte (IA)
Ingénieur en génie logiciel
elmouelhi.achref@gmail.com
H & H: Research and Training 1 / 48

Plan
1 Introduction
2 Premier exemple
3 Avec les assertions
4 Pre/Post test
5 Mockito
6 JUnit et Maven
7 Autres annotations
8 Recouvrement du code

Introduction
JUnit
JUnit ?
Framework open source pour Java créé par Kent Beck et Erich
Gamma
I c

H
Permettant d’automatiser les tests et de s’assurer que le
EL
programme répond toujours aux besoins
U
Basé sur les assertions qui vL MOsi les résultats de tests
érifient
r e f E attendus
correspondent aux résultats
h
Membrecde A
c
la famille XUnit (CPPUnit pour C++, CUnit pour C,
PHPUnit pour PHP...)
Objectif
Trouver un maximum de bugs pour les corriger

Introduction
JUnit
TestCase (cas de test)

Classe Java
I c
LH
Contenant quelques méthodes de test (annotées par @Test)
Ed’une
O U
Permettant de tester le bon fonctionnement classe (en
L M
testant ses méthodes)
re f E
c h
c A
Remarque
Si le test ne détecte pas d’erreur ; il n’y en a pas.

Premier exemple
JUnit
Étape
Création d’un Java Project

I c

H
EL et
U
Création de deux Package : org.eclipse.main
org.eclipse.test
L MO
e
Pour chaque classercr
E
éfée dans org.eclipse.main, on lui
associe uneA h
c de test (dans org.eclipse.test)
classe
c
On prépare le test et ensuite on le lance : s’il y a une erreur, on la
corrige et on relance le test.

Premier exemple
JUnit
Création d’une première classe Calcul

package org.eclipse.main;
I c

public class Calcul {
public int somme(int x, int y) { ELH
U
return x + y;
L MO
}
f E
hre
public int division(int x, int y) {
c
if (y == 0)
c A

throw new ArithmeticException();
return x / y;
}
}

Premier exemple
JUnit
Pour créer une classe de test
Faire un clic droit sur le package org.eclipse.test
Aller dans New > JUnit Test Case
I c
Saisir le nom CalculTest dans Name
EL H
Cocher les 4 cases de Which method stubsU
MO
would you like to
create ?
L
fdeEClass under test
Cliquer sur Browse en r
c h e
face
Chercherc
A
calcul, sélectionner Calcul - org.eclipse.main et valider
Cliquer sur Next puis cocher les cases correspondantes de somme et

division dans Calcul
Cliquer sur Finish puis sur ok (pour valider Add JUnit 5 library to the
build path dans Perform the following action:)

Premier exemple
Le code généré :
package org.eclipse.test;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
class CalculTest {
@BeforeAll
I c

static void setUpBeforeClass() throws Exception { }
ELH
@AfterAll
U
MO
static void tearDownAfterClass() throws Exception { }
@BeforeEach
void setUp() throws Exception {
f E L}
@AfterEach
chre
c A
void tearDown() throws Exception { }
@Test

void testSomme() {
fail("Not yet implemented");
}
@Test
void testDivision() {
fail("Not yet implemented");
}
}

Premier exemple
JUnit
Nous parlerons de ces quatre méthodes dans une autre section
@BeforeAll
static void setUpBeforeClass() throws Exception {
}
I c

@AfterAll H
EL Exception {
U
}
L MO
static void tearDownAfterClass() throws
@BeforeEach chr
ef E
c Athrows Exception {

void setUp()
}
@AfterEach
void tearDown() throws Exception {
}

Premier exemple
JUnit
Pour tester
I c

Faire un clic droit sur le la classe de test
Aller dans Run As > JUnit Test UE
LH
L MO
h r e fE
A c
c

Premier exemple
JUnit
Pour tester
I c

Faire un clic droit sur le la classe de test
Aller dans Run As > JUnit Test UE
LH
L MO
h r e fE
A c
Résultat
c
2 Exécutions : 2 Échecs : car les deux méthodes de test sont vides

Premier exemple
JUnit
Implémentons testSomme() en ciblant chaque fois les cas particuliers
void testSomme() {
Calcul calcul = new Calcul();
if (calcul.somme(2, 3) != 5)
fail("faux pour deux entiers positifs");
I c

if (calcul.somme(-2, -3) != -5)
ELH
fail("faux pour deux entiers négatifs");
U
if (calcul.somme(-2, 3) != 1)
L MO
E
fail("faux pour deux entiers de signe différent");
f
chre
c A
fail("faux pour x nul");

fail("faux pour y nul");
fail("faux pour x et y nuls");
}

Premier exemple
JUnit
Implémentons testSomme() en ciblant chaque fois les cas particuliers
void testSomme() {
I c

if (calcul.somme(-2, -3) != -5)
ELH
fail("faux pour deux entiers négatifs");
U
if (calcul.somme(-2, 3) != 1)
L MO
E
fail("faux pour deux entiers de signe différent");
f
chre
c A
fail("faux pour x nul");

fail("faux pour y nul");
fail("faux pour x et y nuls");
}
En testant, plus d’échec pour somme.

Avec les assertions
JUnit
Nous pouvons réaliser des tests en utilisant les assertions
assertTrue(condition, message) : permet de vérifier que

la condition fournie en paramètre est vraie
I c

ELH
assertFalse(condition, message) : permet de vérifier que
la condition fournie en paramètre est fausse U
L MO
E
assertEquals(valeur attendue, appel de méthode,
f
A c
assertNotEquals)
hre
message) : permet de vérifier l’égalité (sa réciproque est
c

assertNotNull(message, object) permet de vérifier, pour
les paramètres utilisés, qu’une méthode ne retourne pas la valeur
null (sa réciproque est assertNull)
...

Avec les assertions
JUnit
Remarques
I c
H
EL d’erreur par
En l’absence d’un message explicite, un message
U
défaut sera affiché.
L MO
Les méthodes assertX()
h r e f Epeuvent aussi avoir la signature
A c
suivante : assertX(message, valeurAttendue,
c
appelDeMéthodeATester)

Avec les assertions
Implémentons la méthode testDivision()
assertFalse(calcul.division(6, 3) == 0, "2 entiers positifs");
assertEquals(2, calcul.division(-6, -3), "2 entiers négatifs");
assertNotNull(calcul.division(-6, 3), "2 entiers de signe diff");
assertTrue(calcul.division(0, 3) == 0, "entier x nul");
Throwable e = null;
I c

try {
calcul.division(2,0);
ELH
}
U
catch (Throwable ex) {
L MO
e = ex;
f E
hre
}
c
assertTrue(e instanceof ArithmeticException);
c A
e = null;
try {

calcul.division(0,0);
}
catch (Throwable ex) {
e = ex;
}
assertTrue(e instanceof ArithmeticException);
}

Avec les assertions
JUnit
Ajouter des valeurs erronées pour avoir un échec

I c
Le message qui a été saisi sera affiché dansL H
El’icleônepanneau
Failure Trace (vous pouvez cliquer O Usur d’écran, Show
M
L View, en face Failure Trace
Stack Trace in Console
f E
e l’erreur dans la console)
pour visualiser les drétails de
c h

Dans ceccas,Ail faut localiser l’erreur, la corriger et relancer

Pre/Post test
JUnit
Dans certains cas

Avant de démarrer un test, il faut faire certains traitements :
instancier un objet de la classe,
I c

se connecter à une base de données,
ELH
U
MO
ouvrir un fichier...
f E L
Après le test, il faut aussi fermer certaines ressources : connexion
chre
à une base de données, socket...
c A


Pre/Post test
JUnit
Dans certains cas

Avant de démarrer un test, il faut faire certains traitements :
instancier un objet de la classe,
I c

se connecter à une base de données,
ELH
U
MO
ouvrir un fichier...
f E L
Après le test, il faut aussi fermer certaines ressources : connexion
chre
à une base de données, socket...
c A
Pour ces cas
On peut utiliser les méthodes setUp() et tearDown() qui sont
respectivement exécutées avant et après l’appel de chaque
méthode de test.

Pre/Post test
Reprenons les quatre méthodes précédentes et modifions le code
@BeforeAll
static void setUpBeforeClass() throws Exception {
System.out.println("BeforeAll");
}
@AfterAll
I c

static void tearDownAfterClass() throws Exception {
ELH
System.out.println("AfterAll");
U
}
L MO
f E
hre
@BeforeEach
c
} c A

System.out.println("BeforeEach");
@AfterEach
System.out.println("AfterEach");
}

Pre/Post test
JUnit
Comprenons les annotations de méthodes précédentes
I c
@BeforeAll : la méthode annotée sera exécutée seulement
avant le premier test H
EécutLée seulement après
U
L MO
@AfterAll : la méthode annotée sera ex
ef E
le dernier test
@BeforeEachc: h la r
méthode annotée sera exécutée avant chaque
test
c A
@AfterEach : la méthode annotée sera exécutée après chaque
test

Pre/Post test
JUnit
Pour mieux comprendre

Lancer le test JUnit
I c

ELH
U
L MO
f E
chre
c A


Pre/Post test
JUnit
Pour mieux comprendre

Lancer le test JUnit
I c

ELH
U
Le résultat L MO
f E
BeforeAll
chre
BeforeEach
AfterEach
c A

BeforeEach
AfterEach
AfterAll

Pre/Post test
Utilisons ces méthodes pour restructurer la classe CalculTest

class CalculTest {
Calcul calcul;
@BeforeAll
static void setUpBeforeClass() throws Exception { }
@AfterAll
static void tearDownAfterClass() throws Exception { }
@BeforeEach
I c

calcul = new Calcul();
ELH
}
U
@AfterEach
L MO
f E
hre
calcul = null;
}
c
c A
@Test

void testSomme() {
// le code précédent sans l’instanciation de calcul
}
@Test
// le code précédent sans l’instanciation de calcul
}
}

Mockito
JUnit
Mock ?
Objet factice (fake object)
I c

permettant de reproduire le comportement d’un objet réel non
implémenté
ELH
U
L MO
f E
chre
c A


Mockito
JUnit
Mock ?
Objet factice (fake object)
I c

permettant de reproduire le comportement d’un objet réel non
implémenté
ELH
U
L MO
f E
Mockito ? A c hre
c
Framework open source pour Java
Générateur automatique de doublures
Un seul type de Mock possible et une seule façon de le créer

Mockito
JUnit
I c

Exemple, supposant qu’on
EL H
a une interface CalculService ayantU
M O une méthode carre()
f L
E sommeCarre() dans Calcul qui
veut développer une méthode
r e
utilise la méthodehcarre() de cette interface CalculService
c
c A

Mockito
JUnit
L’interface CalculService
I c

E LH
U
MO{
public interface CalculService
L
h r e
public int carre(intf Ex);
A c
} c

Mockito
JUnit
La classe Calcul
public class Calcul {

I c

CalculService calculService;
EL {H
U
L MO
public Calcul(CalculService calculService)
this.calculService = calculService;
}
h r e fE
A c
c
somme(calculService.carre(x),
public int
return
sommeCarre(int x, int y) {
calculService.
carre(y));
}
// + le code précédent

Mockito
JUnit
Pour tester la classe Calcul dans TestCalcul, il faut commencer par
instancier CalculService
class CalculTest {
Calcul calcul;
I c

EL H
@BeforeEach
O U
L M
}
h r fE
calcul = new Calcul(calculService);
e
A c
@Test c
void testSommeCarre() {
assertTrue(calcul.sommeCarre(2, 3) == 13, "calcul
exact");
}
// + le code precedent

Mockito
JUnit
En testant, on aura l’erreur suivante
java.lang.NullPointerException
at org.eclipse.main.Calcul.sommeCarre(Calcul.java:6)
at org.eclipse.test.CalculTest.testSommeCarre(CalculTest.
java:26)
I c

ELH
U
L MO
f E
chre
c A


Mockito
JUnit
En testant, on aura l’erreur suivante
java.lang.NullPointerException
at org.eclipse.main.Calcul.sommeCarre(Calcul.java:6)
at org.eclipse.test.CalculTest.testSommeCarre(CalculTest.
java:26)
I c

ELH
U
L MO
Explication
f E
chre
c A
La source de l’erreur est l’appel de la méthode carre(x) qui n’est pas

implémenté.
Pour corriger cette erreur, on peut utiliser les STUB
STUB (les bouchons en français) : classes qui renvoient en dur une valeur pour
une méthode invoquée

Mockito
JUnit
Pour tester la classe Calcul dans TestCalcul, il faut
commencer par instancier CalculService
class CalculTest {
Calcul calcul;
I c

H
ELCalculService()
U
CalculService calculService = new
{
L MO
h r e fE
@Override
A ccarre(int x) {
//
c
public int
TODO Auto-generated method stub
return x * x;
}
};
// + le code précédent

Mockito
JUnit
En testant
I c

tout se passe bien et le test est passé.
ELH
U
L MO
f E
chre
c A


Mockito
JUnit
En testant
I c

ELH
U
L MO
f E
c
On peut utiliser les mocks
A hre
c
pour cr
éer un objet factice de CalculService

Mockito
JUnit
Démarche
Aller dans
I c

ELH
https://jar-download.com/artifacts/org.mockito et
U
MO
télécharger mockito-core
f E L
Créer un répertoire lib à la racine du projet
chre
c A
Décompresser l’archive mockito-core et copier les 4 .jar
dans lib
Ajouter les .jar de lib au path du projet

Mockito
JUnit
Commençons par importer mockito dans la classe CalculTest
import static org.mockito.Mockito.*;
I c

ELH
U
L MO
f E
chre
c A


Mockito
JUnit
I c
Remplaçons l’instanciation de CalculService par un mock
EL H
U
CalculService calculService = mock(CalculService.class);
L MO
h r e fE
A c
c

Mockito
JUnit
I c
Remplaçons l’instanciation de CalculService par un mock
ELH
U
CalculService calculService = mock(CalculService.class);
L MO
r e E
f devient
c h
La méthode testSommeCarre() ainsi
@Test
c A
when(calculService.carre(2)).thenReturn(4);
assertTrue(calcul.sommeCarre(2, 3) == 13, "calcul exact");

Mockito
JUnit
En testant
I c

ELH
U
L MO
f E
chre
c A


Mockito
JUnit
En testant
I c

Pour vérifier que notre mock a bien été appelé
ELH
U
MO
on peut utiliser la méthode verify
f E L
chre
c A


Mockito
JUnit
En testant
I c

Pour vérifier que notre mock a bien été appelé
ELH
U
MO
on peut utiliser la méthode verify
f E L
c h reà testSommeCarre()
c A
Ajoutons la méthode verify
@Test
verify(calculService).carre(2);
}

Mockito
JUnit
Et si on n’appelle plus la méthode carre() de CalculService dans Calcul
public int sommeCarre(int x, int y) {

return somme(x * x, y * y);
}
I c

ELH
U
L MO
f E
chre
c A


Mockito
JUnit
Et si on n’appelle plus la méthode carre() de CalculService dans Calcul
public int sommeCarre(int x, int y) {

return somme(x * x, y * y);
}
I c

EL H
OU
Testons de nouveau testSommeCarre()M
fE L
@Test
h
c { r e
c A
void testSommeCarre()
}

Mockito
JUnit
Le résultat est
Wanted but not invoked:
calculService.carre(2);
I c

-> at org.eclipse.test.CalculTest.testSommeCarre(
ELH
CalculTest.java:39)
U
MO
Actually, there were zero interactions with this mock.
L
f E
chre
c A


Mockito
JUnit
Le résultat est
Wanted but not invoked:
calculService.carre(2);
I c

-> at org.eclipse.test.CalculTest.testSommeCarre(
ELH
CalculTest.java:39)
U
MO
Actually, there were zero interactions with this mock.
L
f E
chre
c A
Explication
tout mock créé doit être invoqué.

Mockito
JUnit
On peut aussi utiliser les annotations
class CalculTest {
Calcul calcul;
@Mock
I c

@Rule
MockitoRule rule = MockitoJUnit.rule();
ELH
U
@BeforeEach
L MO
f E
hre
MockitoAnnotations.initMocks(this);
c
calcul = new Calcul(calculService);
}
@Test c A

}
// + les autres tests

JUnit et Maven
JUnit
Commençons par créer un Java Project avec Maven

Aller dans File > New > Other
I c

Chercher puis sélectionner Maven Project
ELH
U
Cliquer sur Next
L MO
f E
Choisir maven-archetype-quickstart
A c
Remplir les champs hre
c
Group Id avec org.eclipse
Artifact Id avec first-junit-maven
Package avec org.eclipse.main

JUnit et Maven
JUnit
Vérifier l’existence des deux répertoires
/src/main/java : code source
/src/test/java : code source de test
... I c

ELH
U
L MO
S’il n’y a pas de src/main/java ou src/test/java
Faire clic droit sur le h r e fE

A c projet
Aller dansc
Path > Configure Build Path...
Build
Cliquer sur Order and Export
Cocher les cases Maven Dependencies et JRE System Library
Cliquer sur Apply and Close

JUnit et Maven
JUnit
Ajouter les dépendances suivantes dans pom.xml
<dependency>
<groupId>org.junit.platform</groupId>
<artifactId>junit-platform-runner</artifactId>
<version>1.2.0</version>
I c

<scope>test</scope>
</dependency>
ELH
U
MO
<dependency>
f E L
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
chre
c A
<scope>test</scope>
</dependency>
<dependency>

<groupId>org.mockito</groupId>
<artifactId>mockito-junit-jupiter</artifactId>
<scope>test</scope>
</dependency>

JUnit et Maven
JUnit
Pour tester
Supprimer les packages générés src/main/java et src/test/java
Copier les deux packages org.eclipse.main et org.eclipse.test dans

src/main/java et src/test/java
I c

ELH
Annoter les classes de test par @RunWith(JUnitPlatform.class)
U
L MO
f E
chre
c A


JUnit et Maven
JUnit
Pour tester
Supprimer les packages générés src/main/java et src/test/java
Copier les deux packages org.eclipse.main et org.eclipse.test dans

src/main/java et src/test/java
I c

ELH
Annoter les classes de test par @RunWith(JUnitPlatform.class)
U
L MO
La classe CalculTest
f E
chre
c A

import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
// + les imports précédents
@DisplayName("Test de la classe Calcul")

@RunWith(JUnitPlatform.class)
class CalculTest {
// + tout le code précédent

Autres annotations
JUnit
Pour désactiver un test, on utilise la notation @Disabled : le test

faux même s’il échoue
I c

@Disabled ELH
U
@Test
L MO
void testSomme() {
f E
if(calcul.somme(2, 3) != 6)
chre
} c A


Autres annotations
JUnit
Utiliser @RepeatedTest pour répéter un test plusieurs fois
@RepeatedTest(3)
void testSomme(RepetitionInfo repetitionInfo) {
assertNotEquals(7, calcul.somme(repetitionInfo.
I c

getCurrentRepetition(),3));
ELH
} U
L MO
f E
chre
c A


Autres annotations
JUnit
Utiliser @RepeatedTest pour répéter un test plusieurs fois
@RepeatedTest(3)
assertNotEquals(7, calcul.somme(repetitionInfo.
I c

getCurrentRepetition(),3));
ELH
} U
L MO
f E
chre
Explication c A

Il faut remplacer @Test par @RepeatedTest
Pour récupérer l’index de l’itération courante, on déclare un objet
de type RepetitionInfo

Autres annotations
JUnit
Utiliser @DispllayName pour utiliser un nom d’affichage

personnalisé pour la classe de test ou la méthode de test (peut
I c

donc contenir des espaces et des caractères spéciaux).
EL H
U
@DisplayName("Test de la classe Calcul")
O
class CalculTest {
L M
...
h r e fE
c
@RepeatedTest(3)
A
c
@DisplayName("Trois tests de la méthode somme")
...

Autres annotations
JUnit
Utiliser @ParameterizedTest pour paramétrer un test
@DisplayName("Test de la methode somme")
@ParameterizedTest
@ValueSource(ints = {2, 3})
void testSomme(int t) {
I c

}
assertNotEquals(5, calcul.somme(t, 1));
ELH
U
L MO
f E
chre
c A


Autres annotations
JUnit
Utiliser @ParameterizedTest pour paramétrer un test
@DisplayName("Test de la methode somme")
@ParameterizedTest
@ValueSource(ints = {2, 3})
void testSomme(int t) {
I c

}
assertNotEquals(5, calcul.somme(t, 1));
ELH
U
L MO
f E
hre
Explication
A c
Il faut remplacer @Test par @ParameterizedTest
c
Cette méthode sera testée deux fois, une fois pour la valeur 2 et une fois pour la
valeur 3
@ValueSource indique les valeurs à injecter dans t lors de chaque appel
Il existe aussi strings, longs et doubles

Autres annotations
JUnit
Pour utiliser l’annotation @ParameterizedTest, il faut ajouter la

dépendance suivante :
I c

<dependency> E L H
U
MO
<groupId>org.junit.jupiter</groupId>
L
h r fE
<artifactId>junit-jupiter-params</artifactId>
e
A c
<scope>test</scope>
c
</dependency>

Autres annotations
JUnit
Pour activer ou désactiver un test selon le système d’exploitation, on utilise soit
@DisabledOnOs soit @EnabledOnOs
@Test
@DisabledOnOs(MAC)
I c

when(calculService.Carre(2)).thenReturn(4);
ELH
U
MO
verify(calculService).Carre(2);
f E L
hre
}
c
c A


Autres annotations
JUnit
@Test
@DisabledOnOs(MAC)
I c

ELH
U
MO
f E L
hre
}
A c
c
Il faut importer la constante MAC
import static org.junit.jupiter.api.condition.OS.MAC;

Autres annotations
JUnit
@Test
@DisabledOnOs(MAC)
I c

ELH
U
MO
f E L
hre
}
A c
c
Il faut importer la constante MAC
import static org.junit.jupiter.api.condition.OS.MAC;
Autres constantes possibles : LINUX, WINDOWS

Autres annotations
JUnit
Pour activer ou désactiver un test selon la version de JRE, on utilise soit
@DisabledOnJre soit @EnabledOnJre
@Test
@DisabledOnOs(MAC)
@EnabledOnJre(JAVA_10)
I c

ELH
U
L MO
E
f
hre
c
c A
}

Autres annotations
JUnit
@Test
@DisabledOnOs(MAC)
I c

ELH
U
L MO
E
f
hre
c
c A
}

Il faut importer la constante JAVA 10
import static org.junit.jupiter.api.condition.JRE.JAVA_10;

Autres annotations
JUnit
@Test
@DisabledOnOs(MAC)
I c

ELH
U
L MO
E
f
hre
c
c A
}

Il faut importer la constante JAVA 10
import static org.junit.jupiter.api.condition.JRE.JAVA_10;
Autres constantes possibles : JAVA 8, JAVA 9

Autres annotations
JUnit
Pour activer ou désactiver un test selon la valeur d’un test logique (on peut
même utiliser une expression régulière), on utilise soit @DisabledIf soit
@EnabledIf
I c

@Test
ELH
U
MO
@DisabledOnOs(MAC)
@DisabledIf("2 * 3 > 4")
f E L
hre
c
c A

}

Recouvrement du code
JUnit
Objectif
On veut vérifier si nos tests couvrent l’intégralité de notre code

Ou s’il y a des zones inaccessibles dans notre code
I c

ELH
U
L MO
f E
chre
c A


JUnit
Objectif
On veut vérifier si nos tests couvrent l’intégralité de notre code
I c

Ou s’il y a des zones inaccessibles dans notre code
ELH
U
MO EclEmma
Pour cela, il faut installer un plugin Eclipse
L
e
Aller dans Help > rInstall
h f E New Software > Add
A cdans Name et http://update.eclemma.org/
c
Saisir EclEmma
dans Location
Cocher la case EclEmma et cliquer sur Next
Terminer l’installation et redémarrer Eclipse

JUnit
Pour tester le recouvrement du code

I c

Aller dans Window > Show View > Other ...
ELH
U
Saisir Coverage et valider
L MO
f E
hre
Aller dans Run
c
les tests
c A
Cliquer sur Coverage et vérifier si votre code est bien couvert par


Langue

Cours Java JUnit

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Cours Java JUnit

Transféré par

Droits d'auteur :

Les tests unitaires avec JUnit 5

Docteur de l’université d’Aix-Marseille

H & H: Research and Training 1 / 48

3 Avec les assertions

H & H: Research and Training 2 / 48

H & H: Research and Training 3 / 48

TestCase (cas de test)

Si le test ne détecte pas d’erreur ; il n’y en a pas.

H & H: Research and Training 4 / 48

Création d’un Java Project

H & H: Research and Training 5 / 48

Création d’une première classe Calcul

H & H: Research and Training 6 / 48

Faire un clic droit sur le package org.eclipse.test

Aller dans New > JUnit Test Case

Cliquer sur Next puis cocher les cases correspondantes de somme et

H & H: Research and Training 7 / 48

import static org.junit.jupiter.api.Assertions.*;

H & H: Research and Training 8 / 48

H & H: Research and Training 9 / 48

H & H: Research and Training 10 / 48

H & H: Research and Training 10 / 48

H & H: Research and Training 11 / 48

En testant, plus d’échec pour somme.

Nous pouvons réaliser des tests en utilisant les assertions

assertTrue(condition, message) : permet de vérifier que

H & H: Research and Training 12 / 48

H & H: Research and Training 13 / 48

Implémentons la méthode testDivision()

H & H: Research and Training 14 / 48

Ajouter des valeurs erronées pour avoir un échec

H & H: Research and Training 15 / 48

Dans certains cas

H & H: Research and Training 16 / 48

Dans certains cas

H & H: Research and Training 16 / 48

Reprenons les quatre méthodes précédentes et modifions le code

H & H: Research and Training 17 / 48

Comprenons les annotations de méthodes précédentes

H & H: Research and Training 18 / 48

Pour mieux comprendre

H & H: Research and Training 19 / 48

Pour mieux comprendre

H & H: Research and Training 19 / 48

Utilisons ces méthodes pour restructurer la classe CalculTest

H & H: Research and Training 20 / 48

H & H: Research and Training 21 / 48

H & H: Research and Training 21 / 48

H & H: Research and Training 22 / 48

H & H: Research and Training 23 / 48

public class Calcul {

H & H: Research and Training 24 / 48

H & H: Research and Training 25 / 48

H & H: Research and Training 26 / 48

Pour corriger cette erreur, on peut utiliser les STUB

H & H: Research and Training 26 / 48

H & H: Research and Training 27 / 48

H & H: Research and Training 28 / 48

H & H: Research and Training 28 / 48

H & H: Research and Training 29 / 48

H & H: Research and Training 30 / 48

H & H: Research and Training 30 / 48

H & H: Research and Training 30 / 48

tout se passe bien et le test est passé.

H & H: Research and Training 31 / 48