Les tests unitaires avec JUnit

L'objectif de ce TP est de vous permettre de prendre en main rapidement JUnit pour mettre en place des tests unitaires en Java. Le TP se décompose en 4 parties. Un compte-rendu est à remettre à la fin du TP. Des consignes quant aux informations à faire figurer dans le compte-rendu sont données au fil du texte. Le travail en binôme est autorisé.

1. Renseignez-vous sur JUnit, et rédigez une présentation de cet outil en une dizaine de lignes dans le compte-rendu. Est-ce une librairie ? Un framework ? A quoi cela sert ? Que peut-on faire avec, etc.

2. Suivez le tutoriel disponible à l'adresse suivante. Notez ce que vous retenez d'essentiel dans ce tutoriel dans votre comte-rendu (moins d'une page, copies de code exclues). Notamment, expliquez rapidement ce que sont les annotations en Java et donnez un exemple clair de fonctionnement. https://netbeans.org/kb/docs/java/junit-intro.html

3. Renseignez-vous sur les extensions disponibles pour JUnit et faites un petit résumé du résultat de vos recherchez dans votre compte-rendu.

1. Comprendre le fonctionnement d'un test.

Soit le code suivant :

SimpleTest.java

import  junit.framework.∗;
public class SimpleTest extends TestCase {
    public SimpleTest(String name) {
        super (name);
    }
 
    public void testSimpleTest () {
        int answer = 2;
        assertEquals((1+1), answer ) ;
    }
}

• Créez une classe

  SimpleTest.java

  contenant le code ci-dessus.

• Adaptez cette classe pour la rendre conforme à JUnit 4.
• Exécutez le test.
• Changez la valeur de la variable answer et relancez le test.
• Dans votre compte-rendu, expliquez ce qui se passe.

2. Regrouper les tests.

Soit le code de la classe à tester suivant :

classeAtester.java

// A C l a s s t h a t a d d s up a s t r i n g b a s e d on t h e A S C I I v a l u e s o f i t s
// c h a r a c t e r s and t h e n r e t u r n s t h e b i n a r y r e p r e s e n t a t i o n o f t h e sum .
public class BinString {
p u b l i c B i n S t r i n g ( ) {}
public
 String convert ( String s ) {
r e t u r n b i n a r i s e ( sum ( s ) ) ;
}
public
}
i n t sum ( S t r i n g s ) {
i f ( s =="") r e t u r n 0 ;
i f ( s . l e n g t h ()==1) r e t u r n ( ( i n t ) ( s . charAt ( 0 ) ) ) ;
r e t u r n ( ( i n t ) ( s . c h a r A t ( 0 ) ) ) + sum ( s . s u b s t r i n g ( 1 ) ) ;
}
public
}
String binarise ( int x) {
i f ( x ==0) r e t u r n " " ;
i f ( x %2==1) r e t u r n "1"+ b i n a r i s e ( x / 2 ) ;
r e t u r n "0"+ b i n a r i s e ( x / 2 ) ;

Soit le code de la classe de test suivant :

classeDeTest.java

import j u n i t . framework . ∗ ;
p u b l i c c l a s s B i n S t r i n g T e s t e x t e n d s TestCase {
private BinString binString ;
public
 B i n S t r i n g T e s t ( S t r i n g name ) {
s u p e r ( name ) ;
}
p r o t e c t e d v o i d setUp () {
b i n S t r i n g = new B i n S t r i n g ( ) ;
}
public
 void testSumFunction () {
i n t expected = 0;
a s s e r t E q u a l s ( e x p e c t e d , b i n S t r i n g . sum ( " " ) ) ;
expected = 100;
a s s e r t E q u a l s ( e x p e c t e d , b i n S t r i n g . sum ( " d " ) ) ;
expected = 265;
a s s e r t E q u a l s ( expected ,
b i n S t r i n g . sum ( " Add " ) ) ;
public
 void testBinariseFunction () {
S t r i n g expected = "101";
a s s e r t E q u a l s ( expected , b i n S t r i n g . b i n a r i s e ( 5 ) ) ;
expected = "11111100";
a s s e r t E q u a l s ( expected , b i n S t r i n g . b i n a r i s e (252));
}
}
public
}
void testTotalConversion () {
S t r i n g expected = "1000001";
a s s e r t E q u a l s ( e x p e c t e d , b i n S t r i n g . c o n v e r t ( "A " ) ) ;

• En vous aidant de la javadoc de JUnit, expliquez dans votre compte-rendu ce que fait la classe BinStringTest.
• Adaptez cette classe de test pour la faire fonctionner avec JUnit 4.
• Exécutez les tests et commentez le résultat dans votre compte-rendu.
• En vous aidant des résultats des tests, corrigez les erreurs dans la classe principale.
• Relancez les tests jusqu’à ce que vous arriviez à faire fonctionne le programme.
• Détaillez la démarche que vous avez suivie dans votre compte-rendu.

1. Sélection du sujet.

En fonction du chiffre qui vous aura été attribué, réalisez l'un des deux sujets ci-dessous.

Sujet 1. Ecrire un programme permettant de calculer toutes les racines carrées des nombres compris entre A et B, A et B étant deux nombres entiers tels que A < B.

Sujet 2. Ecrire un programme permettant d'afficher une matrice de taille MxN remplie de nombres aléatoires compris entre A et B. Les valeurs M, N, A et B doivent être passées en paramètre.

2. Travail à faire.

• Ecrivez le squelette de la classe principale et commentez-le.
• Ecrivez l'intégralité de la classe test. Cette classe doit comprendre :
  • des assertions,
  • des tests vérifiant que les exceptions sont bien levées quand elles doivent l'être,
  • des tests vérifiant que les boucles s'effectuent dans des temps raisonnables.
• Formatez correctement les sorties de vos tests en utilisant les annotations @Before et @After.
• Décrivez votre démarche dans votre compte-rendu.

3. Échangez votre travail avec votre voisin.

4. Sur le nouveau code obtenu :

• Implémentez la classe principale.
• Appliquez les tests
• Itérez jusqu'à obtention d'un programme fonctionnel et satisfaisant l'ensemble des tests.
• Décrivez votre démarche dans votre compte-rendu.

5. Question bonus.

Pouvez-vous estimer la couverture structurelle de vos tests, pour chacun des exercices réalisés dans ce TP ?

• http://junit.org
• http://junit.sourceforge.net
• http://github.com/KentBeck/junit/downloads
• http://junit.sourceforge.net/doc/cookbook/cookbook.htm
• http://fr.openclassrooms.com/informatique/cours/les-tests-unitaires-en-java
• http://www.slideshare.net/ohoareau/intro-sur-les-tests-unitaires