Outil de test structurel pour JAVA/JML - Université de Franche

FIEUX Corentin
GÉRARDIN Charles
Outil de test structurel pour JAVA/JML
Projet annuel de seconde année de Master Informatique
Année 2010 – 2011
Tuteurs : Frédéric DADEAU, Fabien PEUREUX
Master 2 Informatique
finalité Professionnelle
option S2L

Table des matières
1)Introduction.......................................................................................................................................3
2)Présentation du sujet.........................................................................................................................5
2.1)Description du sujet...................................................................................................................5
2.2)Cahier des charges.....................................................................................................................6
2.2.1)Contraintes fonctionnelles.................................................................................................7
2.2.2)Contraintes Techniques......................................................................................................8
2.2.3)Autres contraintes..............................................................................................................8
3)Réalisation.........................................................................................................................................9
3.1)Analyse......................................................................................................................................9
3.1.1)Répartition des tâches........................................................................................................9
3.1.1.1)Fragmentation du sujet...............................................................................................9
3.1.1.2)Planning...................................................................................................................10
3.1.2)Choix des outils...............................................................................................................10
3.1.2.1)Sorcerer....................................................................................................................10
3.1.2.2)JavaDoc....................................................................................................................11
3.1.3)Modélisation....................................................................................................................12
3.1.3.1)Méta-modèle JAVA..................................................................................................12
3.1.3.2)Modélisation du graphe de flot de contrôle.............................................................15
3.2)Développement........................................................................................................................18
3.2.1)Implémentation de la structure de données.....................................................................18
3.2.2)Développement du Parser................................................................................................18
3.2.2.1)Variables de stockage...............................................................................................18
3.2.2.2)Méthodes de visite...................................................................................................19
3.2.2.2.1)Le traitement commun.....................................................................................20
3.2.2.2.2)Les méthodes représentant une condition........................................................20
3.2.2.2.3)Les méthodes représentant une instruction......................................................21
3.2.2.2.4)Les autres méthodes.........................................................................................21
3.2.3)Implémentation de la structure des graphes.....................................................................23
3.2.4)Parcours de graphe...........................................................................................................23
3.2.4.1)La fonction Parcours().............................................................................................24
3.2.4.2)La fonction ParcoursBoucle()..................................................................................25
3.2.5)Test...................................................................................................................................26
3.2.6)Documentation.................................................................................................................26
4)Résultat............................................................................................................................................27
4.1)Fichier JAVA analysé...............................................................................................................27
4.2)Structure Correspondante........................................................................................................28
4.3)Graphe résultant.......................................................................................................................28
4.4)Couverture du graphe..............................................................................................................29
5)Bilans...............................................................................................................................................30
5.1)Bilan pédagogique...................................................................................................................30
5.2)Bilan humain...........................................................................................................................30
6)Conclusion.......................................................................................................................................31

1) Introduction
L'informatique est aujourd'hui omniprésente dans notre vie quotidienne, de façon plus ou
moins perceptible, et à tel point qu'il serait difficile, voire impossible de s'en passer.
L'automatisation des procédures est de plus en plus recherchée afin de gagner en temps et en
efficacité.
Cependant et malgré l'influence des programmes informatiques au quotidien, tous n'ont pas
bénéficié du même soin accordé lors de leur développement. En effet, si l'on conçoit qu'une
anomalie dans un programme gérant une machine à café aie des conséquences limitées, on imagine
mal un programme de pilotage d'avion qui risque à tout moment de planter et qui ne soit donc pas
sûr à 100 % (même si cette sûreté totale reste utopique). Ces systèmes, dont les actions sont
essentielles et sensibles, sont dit « critiques » ; parmi eux, on peut citer les systèmes mettant en jeu
d'importantes sommes d'argent (transactions bancaires, projet coûteux tel celui d’une navette
spatiale) ou même des vies humaines (avions, centrales).
Si lors des débuts de l'informatique le fait de tester une application afin d'en limiter les
risques de plantage était complètement occulté, c'est aujourd'hui un aspect tout aussi important que
la conception du programme lui-même et ce pour plusieurs raisons. La première étant évidement la
sécurité ; comme nous l'avons évoqué précédemment, la sûreté d'un programme est essentielle dans
les systèmes critiques. La seconde est économique ; en effet, si le fait de tester un programme
s'avère une phase coûteuse, elle est cependant amortie par la suite lors de la phase de maintenance
qui s'en trouve grandement allégée. Et enfin, la dernière raison est la satisfaction du client qui aura
évidement une confiance accrue en un programme testé et « sûr » plutôt qu'en un programme qui ne
l'est pas. La concurrence au sein du monde de l'informatique étant importante, l'aspect du test est
donc naturellement passé sur le devant de la scène lors du développement d'une application.
Il existe de nombreuses manières de tester un logiciel et ce à différents niveaux. Parmi ces
techniques, le test structurel ou « boîte blanche» consiste à analyser le comportement d'un
programme dont on connaît la structure interne ; cela a l'avantage de générer une liste exhaustive
des comportements du programme suivant les données qu'il traite, et permet ainsi de détecter des
erreurs subtiles là où un test fonctionnel ou « boîte noire» (par opposition à boîte blanche) serait
passé à coté.
Un aspect important de l'activité de test est qu'elle s'adapte à tous les langages de
programmation, de plus en plus nombreux, avec une complexité variable lors de sa mise en place.
La facilité et l'efficacité à tester un programme n'est donc pas une caractéristique négligeable au
moment du choix du langage de programmation d'une application. Et dans la jungle actuelle des
langages informatiques, certains parviennent à tirer leur épingle du jeu ; c'est le cas du langage
JAVA, énormément utilisé car il offre un excellent compromis entre accessibilité aux développeurs
et performances ; il est donc important que ce langage compte des outils de test. Qui plus est, au
langage JAVA se rajoute un module d'annotation : le JML1. Il permet d'annoter des éléments du code
suivant le paradigme de programmation par contrat, et permet ensuite, à l'aide d'un vérificateur
d'assertion, de prouver le programme.
1 JML (JAVA Modeling Language) : langage de spécification pour le JAVA basé sur la programmation par contrat.
3

C'est dans cet aspect de test structurel d'un programme JAVA annoté en JML que s'inscrit
notre projet annuel de seconde année de Master Informatique option S2L (Sécurité et Sûreté du
Logiciel) à l'Université de Franche-Comté. Ce projet spécifique à l'option S2L vise à mettre en
application les connaissances acquises au cours de l'année en ce qui concerne le test et la sûreté d'un
programme.
4

2) Présentation du sujet
2.1) Description du sujet
L'Université de Franche-Comté compte de nombreux laboratoires comptant eux-mêmes
plusieurs équipes. L'équipe VESONTIO2 est une des équipes du laboratoire Informatique de
l'Université : le LIFC3 ; l'un des travaux qu'elle réalise porte sur la validation du code JAVA annoté
en JM.
Durant les cinq mois de deuxième année de Master Informatique que les étudiants passent à
l'Université de Franche-Comté, un projet annuel est attribué à chaque binôme d'étudiants suivant
leur option. L'équipe VESONTIO a donc profité de l'occasion pour soumettre un projet dont la
réalisation apportera une aide à son travail.
Le projet consiste, à partir d'un programme JAVA annoté en JML, à extraire les éléments du
programme (classes, méthodes, attributs, … ) ainsi que les éléments JML (invariant, post-condition,
… ), à les stocker dans une structure qui comportera également des opérations permettant de
générer des éléments nécessaires à un test structurel comme le graphe de flot de contrôle4 (cf.
Figure 1) ainsi que les chemins de couverture de graphe suivant les critères classiques (tous les
nœuds, tous les arcs, tous les n-chemins) ; ces opérations étant également à implémenter lors du
projet.
2 VESONTIO : VErification, SpécificatiON, Test et Ingénierie des mOdèles,
3 LIFC : Laboratoire Informatique de Franche-Comté
4 Graphe de flot de contrôle : mise en forme d'une programme informatique suivant un graphe dont les nœuds sont des
instructions ou des conditions.
5