Processus de vérification d’un outil élémentaire développé avec

des méthodes classiques

Ce processus est applicable pour chaque outil élémentaire développé avec les technologies classiques (Java dans GeneAuto) selon le processus de dévelop- pement présenté dans la section4.3.1.

4.4.1.1 Vérification de la spécification

Les activités de cette étape se résument par les point suivants. Il s’agit essen- tiellement de vérifier, par relecture, que :

– les données de spécifications sont complètes. Autrement dit, il s’agit de vérifier que les exigences de l’architecture de l’outil sont applicables à l’outil élémentaire ;

– les entrées et les sorties des outils élémentaires sont explicitées ainsi que le domaine d’application ;

– les exigences sont correctes et précises vis-à-vis des besoins identifiés. Elles doivent inclure la description fonctionnelle de l’outil élémentaire et les entrées/sorties associées ;

– les exigences sont vérifiables : leur description est basée sur les entrées/- sorties de l’outil élémentaire ;

– les algorithmes sont décrits correctement par rapport aux besoins atten- dus ;

– les informations de traçabilité sur l’architecture de GeneAuto sont in- cluses.

– les exigences comportent les détails d’utilisation (telle que l’installation, les messages d’erreurs, etc.) ;

– les exigences de robustesse sont fournies et couvrent le lancement de Ge- neAuto en dehors de son domaine d’utilisation. Les messages d’erreurs adéquats sont clairement indiqués.

La relecture indépendante des spécifications est appliquée pour accomplir cette vérification.

4.4.1.2 Vérification de la conception

Les activités de vérification appliquées à la conception concernent la vérifica- tion des données de conception, la conformité aux standards ainsi que l’analyse de traçabilité.

4.4.1.2.1 Vérification des données de conception

Cette vérification vise à assurer que :

– l’architecture de l’outil élémentaire définie en Uml couvre toutes les exi- gences définies dans la phase de spécification ;

– la conception des composants qui ne sont pas directement liés à la spéci- fication est justifiée. Une explication sur leur présence est fournie puisque la conception ne découle pas seulement de la spécification mais d’autres contraintes ou choix arbitraires ;

– les composants extérieurs appelés par l’outil élémentaire sont identifiés ainsi que leurs comportements qui ne doivent pas aller à l’encontre des exigences fonctionnelles ;

– les descriptions textuelles relatives à la conception des composants sont correctes et consistantes (c’est-à-dire elles couvrent tous les comporte- ments possibles des composants), et les algorithmes sont corrects et pré- cis ;

– les exigences raffinées pour préciser des comportements non dérivables depuis les exigences sont correctes par rapport aux besoins définis. La vérification des données de conception est accomplie par relecture.

4.4.1.2.2 Vérification de la conformité aux standards

Cette étape consiste à vérifier que les composants de la conception sont conformes aux standards de la conception. Les règles du standard sont défi-

nies de telle sorte que la description des composants de la conception de l’ar- chitecture soit correcte. La connexion des différents composants est également vérifiée afin d’assurer leur consistance.

Analyse de la traçabilité

La traçabilité consiste à assurer que toutes les exigences spécifiées sont cou- vertes par la phase de conception. De plus, les éléments de conception ne fai- sant pas référence directement à la spécification sont clairement identifiés et leur existence doit être justifiée.

La traçabilité entre les données de spécification et les données de conception est automatiquement vérifiée par un outil qui analyse les annotations données dans les commentaires des différents documents. L’outil utilisé dans le cadre de GeneAuto est TRAMWAY. Ce dernier identifie les exigences non couvertes par la conception d’un composant, ainsi que les éléments de conception ne faisant pas référence à la spécification.

4.4.1.3 Vérification de l’implantation

Les données devant être vérifiées par cette phase sont le code source (y compris le code généré par l’analyseur AntLr) et le fichier Jar généré à l’issue de l’outil élémentaire.

Trois points essentiels constituent les activités de cette phase :

Relecture de code source : Elle consiste à s’assurer, par relecture, que tous les éléments de conception sont implémentés en une seule fonction ou pro- cédure et que toutes les données sont utilisées. De plus, il est également vérifié par relecture de code source que toutes les exigences identifiées dans la conception sont implémentées dans le code.

Vérification de conformité aux standards : Il s’agit de vérifier que le code source est conforme aux standards d’implantation. L’outil CheckStyle est utilisé pour cette activité.

Vérification de fichiers Jar : Le fichier Jar généré est vérifié par relecture afin de s’assurer qu’il est sans erreur.

La figure4.3résume les étapes de vérification de code ainsi que les techniques utilisées pour cette fin.

4.4.1.4 Vérification des outils élémentaires

L’objectif est de vérifier chaque outil élémentaire dans son format exécutable (fichier Jar). Cette phase se découpe en cinq étapes :

Tests fonctionnels des outils élémentaires : Cette phase a pour but de vérifier que l’exécution de l’outil est conforme aux exigences définies dans les données de spécification. Il faut définir, dans un premier temps, des cas de tests. Chaque cas de test fait référence à une exigence en déterminant les valeurs d’entrée et et les valeurs de sortie attendues. Ensuite, les cas de tests sont traduits en procédures de tests en utilisant l’outil JUnit de Java. Les procédures de tests sont exécutées pour comparer automatiquement les résultats avec ceux attendus ;

Tests unitaires : Cette étape complète l’étape précédente en prenant en compte les composants de conception qui raffinent les exigences ou les com- plètent. Les tests unitaires vérifient que l’exécution d’un élément de

Objectif Activité Procédure

Le code source correspond Relecture de code source Relecture aux données de conception

Le code source Relecture de source code Relecture correspond à l’architecture

Le code source est consistent Relecture de code source Relecture Le code source est vérifiable Vérification de Check Style

correspondance aux standards

Le code source correspond Vérification de Check Style aux standards correspondance aux standards

Relecture de code source Relecture Chaque fonction/procédure du Relecture de code source Relecture code source implante un seul

composant de conception

Les fichiers Jar sont Vérification de fichiers Jar Vérification

correctement produits auto.

Fig. 4.3 – Processus de vérification de codage

conception est conforme aux exigences fonctionnelles définies dans la conception ;

Lecture de tests : Cette activité consiste à relire les résultats des tests unitaires. Il s’agit, dans un premier temps, d’effectuer un test unitaire sur chaque élément de la conception qui raffine ou contient des exigences dérivées. Une analyse complémentaire est conduite pour s’assurer que les cas de tests sont complets ;

Analyse de traçabilité : Elle a pour objectif de vérifier que toutes les exigences de la spécification et de la conception sont couvertes par les tests. La tra- çabilité est automatiquement réalisée par l’outil TRAMWAY. Ce dernier est appliqué entre les cas de tests et les exigences et entre les procédures de tests et les cas de tests ;

Analyse de couverture structurelle : La couverture structurelle se focalise sur la conception. Cette étape vérifie que les tests unitaires couvrent tout le code source de l’outil élémentaire. Elle préconise, également, d’identifier les parties du code source qui ne sont pas exécutées. Si tel est le cas, soit la couverture des exigences est incomplète et il faudra donc développer de nouveaux cas et procédures de tests, soit le code reste inatteignable par les tests et, par conséquent, il faut supprimer le code mort ou justifier les cas où le code est gardé.

La figure4.4récapitule les étapes de vérification concernées par les tests effec- tués sur l’outil élémentaire.

Objectif Activité Procédure

Le code exécutable est conforme Test d’outils élémentaires Test à la spécification

Le code exécutable est robuste par rapport à la spécification

Le code exécutable est conforme Tests unitaires avec les données de conception

Le code exécutable est robuste par rapport à la conception

Les résultats des tests sont corrects Relecture de tests Relecture Les fonctions réalisées par les

composants extérieurs sont correctes

La spécification est couverte par Analyse de traçabilité Outil de

les tests traçabilité

La conception est couverte par les tests

L’architecture du logiciel est couverte Analyse de couverture Outil d’analyse

par les tests structurelle de couverture

structurelle

Fig. 4.4 – Processus de test des outils élémentaires