Conception par contrats en JML et vérification à l'exécution

Transcription

1 Conception par contrats en JML et vérification à l'exécution Delphine Longuet

2 Spécifications formelles Orientées contrôle : Représentation de la dynamique du système automates finis étendus, machines à états UML réseaux de Petri, diagrammes d'activité UML langages synchrones (Lustre, Scade) Exemple : Machine à états d'un ascenseur [f = current] door := true ask(f) [f > current] door := false f := f + 1 current := 0 door := false [f = current] door := true [f = current] door := true [f < current] door := false f := f - 1 2

3 Spécifications formelles Orientés données : Représentation de l'évolution des données méthode B OCL pour UML JML (pour Java), ACSL (pour C), Spec# (pour C#) Exemple : Spécification JML pour la division entière /*@ requires b!= ensures 0 <= a - (b * \result) && a - (b * \result) < b; public static int div(int a, int b) {... 3

4 Java Modelling Language Langage de spécification pour Java, basé sur la conception par contrats public class Compte { invariant pré-condition post-condition private double solde; //@ invariant solde >= 0; /*@ requires montant > 0 && solde >= ensures solde == \old(solde) montant; public void debiter(double montant) {... 4

5 Utilisations des spécifications JML Runtime assertion checking : vérification à l'exécution des spécifications Outil : jmlc/jmlrac compilation et vérification des spécifications Extended static checking : analyse statique du programme et de ses spécification dans le but de trouver des erreurs à l'exécution (indice hors des bornes, problème d'aliasing...) Outil : ESC/Java2 Preuve : vérification déductive de la correction du programme par rapport à ses spécifications Outils : KeY, JACK, Krakatoa 5

6 Conception par contrats Principe : contrat entre une classe et ses clients Pré-conditions : conditions que le client garantit pour appeler une méthode de cette classe Post-conditions : propriétés que la classe garantit être vérifiées après l'appel Contrats JML exécutables : spécifications compilées vers du code détection des violations des contrats à l'exécution 6

7 Java Modelling Language Spécifications comme annotations Java public class Compte { propriété terminée par un point-virgule private double solde; //@ invariant solde >= 0; /*@ requires montant > 0 && solde >= ensures solde == \old(solde) montant; public bool debiter(double montant) {... ligne commençant par //@ ou entre /*@ et 7

8 Invariants en JML Invariant : propriété qui doit être vérifiée à tout moment de la vie d'un objet (contrainte) à la construction avant et après chaque appel de méthode private double solde; //@ invariant solde >= 0; private Object[] elems; private int size; /*@ invariant size >= invariant (\forall int i; size <= i && i < elems.length; elems[i] == null); 8

9 Invariants en JML Invariant : propriété qui doit être vérifiée à tout moment de la vie d'un objet (contrainte) à la construction avant et après chaque appel de méthode private double solde; //@ invariant solde >= 0; public Compte(double s) { this.solde = s; public void crediter(double m) { solde = solde + m; public bool debiter(double m) { solde = solde m; return true; 9

10 Invariants en JML Invariant : propriété qui doit être vérifiée à tout moment de la vie d'un objet (contrainte) à la construction avant et après chaque appel de méthode private double solde; //@ invariant solde >= 0; public Compte(double s) { this.solde = s; public void crediter(double m) { solde = solde + m; public bool debiter(double m) { solde = solde m; return true; si s < 0, invariant violé à la création de l'objet Compte si m >= solde, invariant violé après l'appel à la méthode retirer 10

11 Invariants en JML Invariant : propriété qui doit être vérifiée à tout moment de la vie d'un objet (contrainte) à la construction avant et après chaque appel de méthode private double solde; //@ invariant solde >= 0; public Compte(double s) { if (s >= 0) { this.solde = s; else { throw new Exception(); public void crediter(double m) { solde = solde + m; public bool debiter(double m) { if (m <= solde) { solde = solde m; return true; return false; Solution 1 : vérification en place 11

12 Invariants en JML Invariant : propriété qui doit être vérifiée à tout moment de la vie d'un objet (contrainte) à la construction avant et après chaque appel de méthode private double solde; //@ invariant solde >= 0; //@ requires s >= 0; public Compte(double s) { this.solde = s; public void crediter(double m) { solde = solde + m; //@ requires m <= solde; public bool debiter(double m) { solde = solde m; return true; Solution 2 : restrictions d'utilisation formulées comme pré-conditions 12

13 Pré et post-conditions en JML Pré-condition : condition nécessaire pour exécuter la méthode (motclé requires) Post-condition : propriété qui doit être vérifiée à la fin de l'exécution de la méthode (mot-clé ensures) //@ requires s >= 0; //@ ensures solde == s; public Compte(double s) {... Si la pré-condition est vérifiée, alors après l'exécution de la méthode, la post-condition doit être vérifiée. Si la pré-condition n'est pas vérifiée, aucune garantie sur l'exécution de la méthode (boucle infinie, levée d'exception...) Valeurs par défaut : true 13

14 Pré et post-conditions en JML Pré-condition : condition nécessaire pour exécuter la méthode (motclé requires) Post-condition : propriété qui doit être vérifiée à la fin de l'exécution de la méthode (mot-clé ensures) //@ requires s >= 0; //@ ensures solde == s; public Compte(double s) { this.solde = s; //@ requires s >= 0; //@ ensures solde == s; public Compte(double s) { this.solde = Math.abs(s); //@ requires s >= 0; //@ ensures solde == s; public Compte(double s) { if (s >= 0) { this.solde = s; else { throw new Exception(); Implantations de Compte vérifiant les pré et post-conditions 14

15 Mots-clés dans les post-conditions \old(e) : valeur de e avant l'exécution de la méthode /*@ requires m > 0 && solde >= ensures solde == \old(solde) m; public void debiter(double m) {... \result : résultat de l'exécution de la méthode (valeur ou objet renvoyé) /*@ requires size > ensures \result == elems[size-1]; public Object top() {... 15

16 Visibilité des attributs et méthodes Remarque : attributs et méthodes utilisés dans les spécifications doivent être public Si private, changer la visibilité pour la spécification avec spec_public (visibilité reste private pour le programme) private /*@ spec_public int solde; //@ invariant solde >= 0; private /*@ spec_public Object[] elems; private /*@ spec_public int size; /*@ invariant size >= invariant (\forall int i; size <= i && i < elems.length; elems[i] == null); 16

17 Éléments non null par défaut Par défaut : non_null a (invariant implicite a!= null) nullable a : si l'attribut a peut être null private /*@ spec_public nullable Object[] tab; public /*@ pure int size() {... public /*@ pure boolean contains() {... contrainte implicite /*@ requires e!= requires size() < tab.length - ensures ensures size() == \old(size()) + 1; public void ajouter(object e) {... 17

18 Méthodes «pures» Méthode pure : méthode sans effet de bord Seules les méthodes pures peuvent être utilisées dans les spécifications. private /*@ spec_public nullable Object[] tab; public /*@ pure int size() {... public /*@ pure boolean contains() {... /*@ requires size() < tab.length - ensures ensures size() == \old(size()) + 1; public void ajouter(object e) {... 18

19 Quantificateurs Universel : pour tout x de type T vérifiant P, Q est vraie. (\forall T x; P(x); Q(x)) //@ ensures (\forall int i; 0 <= i && i < tab.length; \result <= tab[i]); public int min() {... Existentiel : il existe x de type T vérifiant P, tel que Q soit vraie. (\exists T x; P(x); Q(x)) //@ ensures (\exists int i; 0 <= i && i < list.size(); \result.equals(list.get(i))); public Personne randomvote(arraylist<personne> list) {... 19

20 Opérations Maximum : valeur maximum que prend l'expression exp lorsque x de type T vérifie P (\max T x; P(x); exp) //@ ensures \result == (\max int i; 0 <= i && i < tab.length; tab[i]); public int max() {... Minimum : \min Somme : \sum Produit :\product Nombre d'éléments : nombre d'éléments x de type T qui vérifient P et Q (\num_of T x; P(x); Q(x)) //@ ensures \result == (\num_of int i; 0 <= i && i < tab.length; tab[i].equals(e)); public int nbocc(object e) {... 20

21 Exécutablité des spécifications Remarque : pour le runtime assertion checking, spécifications compilées vers code exécutable pour pouvoir être vérifiées à l'exécution Spécification exécutable /*@ requires (\forall int i; 0 <= i && i < t.length; t[i] == 0); Spécification non exécutable... /*@ requires (\forall Personne p; list.contains(p); p.age >= 18);... rendue exécutable /*@ requires (\forall int i; 0 <= i && i < list.size(); list.get(i).age > 18); 21

22 Spécification des exceptions et spécifications structurées 22

23 Exceptions Post-condition en cas de terminaison normale de la méthode ensures P Post-condition en cas de levée d'une exception e de type E signals (E e) P si terminaison normale /*@ ensures \result == signals (ArithmeticException) x == signals (NullPointerException) y == null; public int strangedivide (int x, Integer y) { return y.intvalue()/x; si levée d'exception 23

24 Spécifications par cas Spécification des différents comportements d'une méthode en fonction des pré-conditions Équivalent à : /*@ requires s >= ensures solde == requires s < ensures solde == 0; public Compte(double s) {... /*@ requires (s >= 0) (s < ensures s >= 0 ==> solde == ensures s < 0 ==> solde == 0; public Compte(double s) {... 24

25 Spécifications par cas Spécification des différents comportements d'une méthode en fonction des pré-conditions requires s >= ensures solde == requires s < ensures solde == 0; public Compte(double s) {... Remarque : pré-conditions pas nécessairement disjointes mais attention à la cohérence des post-conditions! /*@ requires s >= ensures solde == requires s <= ensures solde == -1; public Compte(double s) {... pour s = 0, solde doit à la fois être égal à 0 et -1 25

26 Spécifications structurées Spécification à plat (non structurée) requires ensures signals (E e) R; public T method() {... Spécification structurée : distinction entre Comportement normal : signal (Exception) false requires ensures signals (E e) false; public T method() {... 26

27 Spécifications structurées Spécification à plat (non structurée) requires ensures signals (E e) R; public T method() {... Spécification structurée : distinction entre Comportement normal : signal (Exception) false /*@ requires ensures signals (E e) false; public T method() {... 27

28 Spécifications structurées Spécification à plat (non structurée) requires ensures signals (E e) R; public T method() {... Spécification structurée : distinction entre Comportement normal : signal (Exception) false Comportement exceptionnel : ensures false /*@ requires ensures signals (E e) false; public T method() {... requires ensures signals (E e) R; public T method() {... 28

29 Spécifications structurées Spécification à plat (non structurée) requires ensures signals (E e) R; public T method() {... Spécification structurée : distinction entre Comportement normal : signal (Exception) false Comportement exceptionnel : ensures false /*@ requires ensures signals (E e) false; public T method() {... /*@ requires ensures signals (E e) R; public T method() {... 29

30 Spécifications structurées Comportement normal : normal_behavior pré-condition : requires P post-conditions : ensures Q Comportement exceptionnel : exceptional_behavior pré-condition : requires P exceptions levées : signals_only E1,...,En sous-ensemble des exceptions levées par la méthode (throws) post-condition pour chacune signals (E1) Q1 des exceptions :... signals (En) Qn 30

31 Spécifications structurées requires m >= 0 && m <= ensures solde == \old(solde) - requires m signals_only MauvaisArgument; signals (MauvaisArgument) solde == requires m > signals_only signals (NonAutorise) solde == \old(solde); public bool debiter(double m) throws MauvaisArgument, NonAutorise { if (m < 0) { throw new MauvaisArgument(); if (m > solde) { throw new NonAutorise(); solde = solde - m; 31