vérification et validation

VÉRIFICATION ET
VALIDATION
mardi 12 février 2008
Vérification et Validation
Validation : Faisons-nous le bon produit ? Le logiciel répond-il aux
besoins des utilisateurs ?
Vérification : Faisons-nous le produit correctement ? Le logiciel est-il
conforme à ses spécifications ?
Tests (nécessite exécutable) ≠ Preuve
Tests unitaires
Tests d'intégration
Tests de non régression
“Testing can prove the presence of bugs, but never their
absence” (Dijkstra)
mardi 12 février 2008
Tests : techniques utilisées
Inspection du logiciel (analyse des documents, fichiers, diagrammes...),
logiciel non exécuté
Test du logiciel : exécution du logiciel (données bien choisies, examen
des résultats)
Tests des défauts : trouver des inconsistances vis-à-vis des
spécifications
Tests statistique : performances et fiabilité sur données «habituelles»
Tests de robustesse : sur données invalides
Impossibilité de tester de façon exhaustive, choix des tests primordial
Nécessité d'un “Oracle”
mardi 12 février 2008
Test (def IEE)
IEEE-STD 610.12-1990
Le test est l'exécution ou l'évaluation d'un système ou d'un
composant par des moyens automatiques ou manuels, pour
vérifier qu'il répond à ses spécifications ou identifier les
différences entre les résultats attendus et les résultats observés"
mardi 12 février 2008
Inspection
Technique efficace de détection des erreurs (jusqu'à 60%)
Relecteurs spécialistes (connaissent langage et erreurs les plus fréquentes)
Avant les tests
Doit exister une spécification précise
A base de check list
Existence d'analyseur statiques
Démarche :
Détection des défauts, anomalies, non respect des standards... par
inspecteur
Correction par auteur
Modérateur décide si oui ou non on ré-inspecte
mardi 12 février 2008
Test Fonctionnels (ou boîte
noire)
Composant considéré comme boîte noire
Tests choisis en fonction des spécifications
Principe : prévoir les résultats de sortie en fonction des valeurs en entrée.
Si les sorties ne sont pas celles prévues alors le test a, avec succès, détecté
un problème.
Problème : choisir les entrées (impossible d’être exhaustif)
Choisir
Valeurs limites
Partitionner les entrées en classes d'équivalence (pour le programme),
choisir un représentant par classe.
mardi 12 février 2008
Tests Fonctionnels : Exemple
Recherche dichotomique
Reçoit en entrée : un tableau classé par ordre croissant et un élément
si l’élément est présent, renvoie sa position
sinon renvoie -1
Jeux de tests
Valeurs limites
Tableau Vide ?? (précondition sur tableau vide ?)
Tableau avec un élément
Premier/Dernier élément
2 classes : élément présent, élément absent
Tableaux de tailles différentes dans des tests différents
mardi 12 février 2008
Exemple : recherche
dichoromique
Tableau
Elément
Tableau
Elément Sortie
Vide
pas présent
()
123
-1
1 elt
présent
17
17
1
1 elt
pas présent
2
12
-1
plus d’1 elt présent, premie
5 12 18 123 345
5
1
plus d’1 elt présent, dernier
123456789
9
9
plus d’1 elt
présent, elt qcq
234 567 890 1515
567
2
plus d’1 elt
pas présent
345 567 789
1515
-1
mardi 12 février 2008
Exemple : ajouteMonome
Méthode ajouteMonome(int coef, int degre) dans la classe
polynome
Jeux de tests
Valeurs limites ???
Classes d'équivalence ???
mardi 12 février 2008
Tests structurels (ou boîte
blanche)
Tests dérivés de la connaissance
du code
Noeud d’entrée unique E et de
sortie unique S
Plutôt pour des méthodes, petits
composants
Principe : exécuter chaque
instruction et chaque chemin
(attention) au moins une fois
Méthode : construction du
graphe de contrôle
Noeuds : instructions
Arcs : branchements
mardi 12 février 2008
IF
WHILE
Complexité Cyclomatique
(CG)
CG = Nombre de chemins
indépendants
CG = Nombre de régions du
graphe
CG = Arêtes - Noeuds +2 =
Point de décision +1
Borne supérieure pour que
toutes les instructions soient
exécutées au moins 1 fois
mardi 12 février 2008
Recherche dichotomique
public static int recherche(int clef, int[] tableau) {
int debut = 0;
int fin = tableau.length - 1;
int resultat = -1; (1) ;
(1) while (debut <= fin) {
int milieu = (debut + fin) / 2;
(2)
if (tableau[milieu] == clef) {
resultat = milieu;
(3)
break;
}
(4)
else if (tableau[milieu] < clef) {
(5)
debut = milieu + 1;}
else {
(6)
fin = milieu - 1;}
(7) }
(8) return resultat;
mardi 12 février 2008
Recherche dichotomique
Calcul de CG :
Nbre de régions du graphe = 4
A - N +2 = 10 -8 +2 = 4
Point de décision +1= 3 +1 = 4
Chemins indépendants
1, 8
1, 2, 3, 8
1, 2 , 4, 5, 7, 1, 8
1, 2 , 4, 6, 7, 1, 8
mardi 12 février 2008
1
2
3
8
4
5
6
7
Principes de test
Un programmeur ne doit pas tester ses propres programmes.
Ne pas effectuer des tests avec l’hypothèse de base qu’aucune
erreur ne va être trouvée.
Définir soigneusement les résultats attendus AVANT
l’exécution d’un test.
Inspecter minutieusement les traces de chaque test.
Penser à tester des entrées invalides.
mardi 12 février 2008
Tests et Java
Assertions
Invariants, pré et post conditions
assert expression;
assert expression 1 : expression 2;
java -ea
junit (www.junit.org)
mardi 12 février 2008
// Polynome.java
public void ajouteMonome(double coef, int degre){
Monome courant liste_; Monome precedent = null;
while (courant != null){
if (courant.degre() == degre) {
courant.ajoute(coef); if (courant.coef() == 0) {
if (precedent != null) {
precedent.set_suivant(courant.suivant());
}
else {
liste_ = courant.suivant(); }
} return; }
if (courant.degre() > degre) { Monome m = new Monome(coef, degre, courant); if (precedent != null) {
precedent.set_suivant(m);
}
else {
else {
liste_ = m;
}
return;
}
precedent = courant;
courant = courant.suivant();
}
if (precedent == null) {
liste_ = new Monome(coef, degre, null);
else {
precedent.set_suivant(new Monome(coef, degre, null));
}
return;
}
mardi 12 février 2008
//
//
//
//
//
//
//
//
I1a
I1b
T2
T3
I3
T4
T5
I5i
// I5e
// FIN
//
//
//
//
T6
I6
T7
I7i
// I7e
// FIN
// I8a
// I8b
// T9
// I9i
// I9e
// FIN
1
T2
2
T9
3
5
I9i
18
9
T3
I9e
4
T6
6
8
17
T4
19
12
22
14
I5i
I5e
15
13
16
FIN
mardi 12 février 2008
I7e
20
T5
11
21
I7i
10
7
T7
23