Gestion des tests avec JUnit
JUnit
Outil de gestion des tests unitaires pour les programmes
Java, JUnit fait partie d’un cadre plus général pour le test
unitaire des programmes, le modèle de conception (pattern)
XUnit (CUnit, ObjcUnit, etc.).
JUnit offre :
• des primitives pour créer un test (assertions)
• des primitives pour gérer des suites de tests
• des facilités pour l’exécution des tests
• statistiques sur l’exécution des tests
• interface graphique pour la couverture des tests
• points d’extensions pour des situations spécifiques
dans une archive Java junit . jar dont le principal paquetage
est junit .framework.
Il existe un plug-in Eclipse pour JUnit.
[Link]
Principe du test avec JUnit
Rappels: test unitaire = test des parties (unités) du code
TestSuite = ensemble de TestCase
1. Pour chaque fichier [Link] créer un fichier
[Link] (dans le même repertoire) qui inclut (au
moins) le paquetage junit .framework.∗
2. Dans [Link], pour chaque classe Foo de [Link]
écrire une classe FooTest qui hérite de TestCase
3. Dans FooTest définir les méthodes suivantes :
• le constructeur qui initialise le nom de la suite de
tests
• setUp appelée avant chaque test
• tearDown appelée après chaque test
• une ou plusieurs méthodes dont le nom est prefixé
par test et qui implementent les tests unitaires
• suite qui appelle les tests unitaires
• main qui appelle l’exécution de la suite
Ecrire les tests unitaires avec Junit
Dans les méthodes de test unitaire, les méthodes testées
sont appelées et leur résultat est testé à l’aide d’assertions :
• assertEquals(a,b)
teste si a est éqal à b (a et b sont soit des valeurs
primitives, soit des objets possédant une méthode
equals)
• assertTrue(a) et assertFalse(a)
testent si a est vrai resp. faux, avec a une expression
booléenne
• assertSame(a,b) et assertNotSame(a,b)
testent si a et b référent au même objet ou non.
• assertNull(a) et assertNotNull(a)
testent si a est null ou non, avec a un objet
• fail (message)
si le test doit echouer (levée d’exception)
Exemple : Conversion binaire/entier
/ / F i l e Binaire . java
import j a v a . i o . ∗ ;
public class B i n a i r e {
private S t r i n g tab ;
public B i n a i r e ( ) { t a b = new S t r i n g ( ) ; }
public B i n a i r e ( S t r i n g b , boolean be ) {
t a b = new S t r i n g ( b ) ; i f ( be ) r e v e r t ( ) ; }
p r i v a t e void r e v e r t ( ) {
byte [ ] btab = t a b . getBytes ( ) ;
for ( int i = 0; i < ( btab . l e n g t h >> 1 ) ; i ++) {
byte tmp = btab [ i ] ; btab [ i ] = btab [ btab . l e n g t h − i ];
btab [ btab . l e n g t h − i ] = tmp ;
}
t a b = new S t r i n g ( btab ) ;
}
public i n t g e t I n t ( ) {
i n t nombre = 0 ;
/ ∗ l i t t l e endian ∗/
f o r ( i n t i = t a b . l e n g t h () − 1; i >= 0 ; i −−) {
nombre = ( nombre << 1 ) + ( t a b . char At ( i ) − ’0 ’ ) ; }
ret urn nombre ; }
}
Exemple : Test Conversion binaire/entier
/ / F i c h i e r BinaireTest . java
import j u n i t . framework . ∗ ;
public class B i n a i r e T e s t extends TestCase {
private Binaire bin ;
public B i n a i r e T e s t ( S t r i n g name ) { super ( name ) ; }
protected void setUp ( ) throws Exception {
b i n = new B i n a i r e ( ) ; }
protected void tearDown ( ) throws Exception {
bin = null ; }
public void t e s t B i n a i r e 0 ( ) {
assertEquals ( b i n . g e t I n t ( ) , 0 ) ; }
public void t e s t B i n a i r e 1 ( ) {
b i n = new B i n a i r e ( ” 01 ” , f a l s e ) ;
assertEquals ( b i n . g e t I n t ( ) , 2 ) ;
}
public s t a t i c Test s u i t e ( ) { / / si
ret urn new T e s t S u i t e ( B i n a i r e T e s t . class ) ; / / or
/ / T e s t S u i t e s u i t e = new T e s t S u i t e ( ) ;
/ / s u i t e . addTest ( B i n a i r e T e s t . s u i t e ( ) ) ;
/ / return suite ;
}
Exécuter une suite de tests
/ / classe Bin a ir e T e st
p u b l i c s t a t i c v o i d main ( S t r i n g args [ ] ) {
j u n i t . t e x t u i . TestRunner . run ( s u i t e ( ) ) ;
}
1. En ligne de commande : (Junit est dans le CLASSPATH)
java BinaryTest
2. En utilisant Eclipse :
• ajouter JUnit dans les libraries du projet
• exécuter [Link] comme test JUnit
• Remarque : dans ce cas, les méthodes mai et suite
ne sont pas nécessaires
Quelques règles de bonne conduite avec JUnit
• Ecrire les test en même temps que le code.
• Tester uniquement ce qui peut vraiment provoquer des
erreurs.
• Exécuter ses tests aussi souvent que possible,
idéalement après chaque changement de code.
• Ecrire un test pour tout bogue signalé (même s’il est
corrigé).
• Ne pas tester plusieurs méthodes dans un même test :
JUnit s’arrete à la première erreur.
• Attention, les méthodes privées ne peuvent pas être
testées !
