Thierry Jéron Habilitation à diriger des recherches 16 mars 2004 Contribution à la génération automatique de tests pour les systèmes réactifs Thierry Jéron Habilitation à diriger des recherches 16 mars 2004

Contexte: les systèmes réactifs Env P1 P2 Exemples: protocoles télécom, systèmes embarqués, systèmes contrôle/commande, etc. Complexité, répartition croissante, criticité Nécessité de fiabilité / maîtrise des coûts  méthodes formelles

Spécification comportementale: exemple du protocole du bit alterné Env RQ(data) IND(data) CNF Receiver Transmitter d:=0 b:=0 s br = b ?DT(d,br) !IND(d) !ACK(b) b:=1-b br ≠ bit ACK(bit) s b:=0 ?RQ(d)/ !DT(d,b) br = b ?ACK(br) / !CNF b:=1-b DT(data,bit) br ≠ bit ?ACK(br) / !DT(d,b) w Processus concurrents, communication (interne-externe), structure de contrôle, données. Langages de spécification : SDL, Lotos, UML, etc

Sémantique : systèmes de transitions (LTS) Spécification comportementale Spec Système de transitions (LTS) S = [[Spec]] simulation exhaustive état: (localités, val(var), files) action état’: (localités, val(var), files) Explosion combinatoire, voire infinitude (données, files)

Vérification de modèle Hyp: Imp modélisable par I Vérification et test Propriété P (automate, logique) Vérification de modèle S ⊨ P ? Spécification Spec  S = [[Spec]] comportementale Test: Imp conforme à S ? I conf S ? Implémentation Imp Hyp: Imp modélisable par I

Génération de tests à la volée (IOLTS) Historique ADP AAR PAMPA VerTeCS 88 92 91 93 96 89 90 94 95 97 98 99 00 01 02 03 04 Représentation model-checking de syst. infinis (YM Quemener,93-96) Non bornitude de files de CFSM Vérification Vérification à la volée Model checking Repr. 3D LTS Génération de tests à la volée (IOLTS) (P. Morel, 96-00) Gen. test (FSM) Observation répartie Test asynchrone & réparti Test de conformité & Observation Génération de tests symbolique (IOSTS) (E. Zinovieva, 00->) Test et jeux Test et contrôle (V.Tschaen, 01->)

Plan Problématique du test Génération de tests à la volée Test asynchrone et réparti Génération de tests symbolique Bilan et perspectives

1. Problématique du test Test = analyse dynamique de programmes pour détecter des fautes par rapport à une spécification. ≠ vérification de modèle : exhaustivité impossible en pratique  Sélectionner les tests : à partir du code : test boîte blanche/structurel à partir de la spécification : test boîte noire Activité coûteuse et souvent artisanale Formaliser est incontournable pour  Améliorer la qualité des tests  Diminuer le coût du test

Test de conformité de systèmes réactifs Pb: tester qu’une implémentation I (boîte noire) est conforme à sa spécification S (supposée correcte). Critères de sélection Générateur de tests S? Spécification S S! I conf S ? S? contrôle Implémentation I Cas de test Verdict S! observation

2. Génération de tests à la volée [CAV96-99,SCP97-00,IWTCS96,Cfip97, IDPT02,TSI03, …] Motivations: Éviter l’explosion combinatoire Traiter des systèmes non déterministes Cadre théorique: Théorie du test des IOTS [Tretmans 95-96] Origines: LTS [DeNicola-Henessy84, Abramsky87, Philips87, Brinksma88] Contribution: Formalisation des objectifs de test Sélection de tests à la volée ← vérification à la volée

Le modèle: les IOLTS IOLTS (input/output LTS) : ~ IOTS [Tretmans96], IOA [Lynch88] sémantique de systèmes réactifs non-déterministes  spécifications, implémentations, tests, objectifs S ?A non-déterminisme observable : Les entrées ne déterminent pas les sorties  non-contrôlabilité ! X ! Y t ?B ?B non-déterminisme (au sens des automates)  incertitude supprimé par déterminisation ! X ! Z

Comportements visibles par le test Le test permet de contrôler les entrées et observer sorties et blocages (timers) distinguer les blocages spécifiés dans S des autres ⇒ calculer les blocages sur S !d Vis(S)=det(D(S)) D(S) Automate de suspension ?A ?B ! Z ! Y t ! X S ?A ?B !Z !Y !X !d Comportements visibles de référence.  Base pour définir la conformité

Relation de conformité Plusieurs choix possibles: inclusion, égalité de traces, de sorties, de refus, etc  ioco [Tretmans96] : après un comportement visible de la spécification, l’implémentation n’est autorisé à produire que les sorties et blocages spécifiées ?A ?B !Z !Y !X !d I S? Entrées non spécifiées I ioco S Spécification partielle Sorties, blocages non spécifiées ¬ (I ioco S) vis(S) S!d

Cas de test et exécutions ?B !Z !Y !X !d Vis(S) ?A ?B !Z !Y !X !d I !A ?Y ?X TC ?d ? Z ! B Inconc Fail Pass ? otherwise ∥ Verdict: Fail, Pass, Inconc Propriétés attendues des algorithmes de génération: Correction : I peut être rejetée par TC ⇒ ¬ (I ioco S) Exhaustivité: ¬ (I ioco S) ⇒ on peut générer TC qui peut rejeter I

Principes de la génération de tests !z * Accept !x S Objectif de test : automate complet TracesAccept(TP) Calcul des blocages !d D(S) Déterminisation TP Vis(S) Algorithme non-déterministe [Tretmans96] [Lestiennes-Gaudel02] Produit: intersection de comportement Vis(S)xTP Sélection + Mirroir + Ajout des verdicts X !A ? !B CTG Conflits de contrôlabilité ? !A TC TC

Étapes de la génération ?B !Z !Y !X Vis(S)) ?C Produit Vis(S)xTP Sélection Verdicts Mirroir CTG Conflits de contrôlabilité TC Init ?d !d ?C ?A !A !Y ?Y !Y Fail ?X !X Inconc ?d !d reach(Init) ∩ coreach(Accept) !Z !d ?B !d ?d ?B !B !z * Accept !x TP ?otherwise ?B !B ?C !Y !Z ?Z Accept Pass reach(Init)

Propriétés des tests générés Correction: possibilité de rejet  non conformité “Exhaustivité”: non-conformité  possibilité de rejet Tests arborescents ⇒ adaptés au non-déterminisme observable

Génération à la volée Spec S Calcul à la volée D(S) TP Vis(S) CTG TC Constat : S très grand ou infini |S| ≫ |TC| Idée: éviter de construire S  construction paresseuse de S, D(S), Vis(S), Vis(S)xTP,CTG pilotée par TP  utilisation d’une représentation implicite des IOLTS  algorithmes basés sur DFS Spec S D(S) Calcul à la volée TP Vis(S) CTG TC

Cas de test (bcg, aut, TTCN, ) Implémentation: TGV Expérimentations dans des domaines variés. Distribution: CADP, Agedis Transfert: ObjectGéode Specification Objectif de test bcg, IF UML SDL Lotos IF Object Géode Caesar open IF open Umlaut API de Simulation (primitives parcours de S) CADP lib TGV Cas de test (bcg, aut, TTCN, )

Résumé de la contribution Algorithmique de la génération de tests sur des modèles énumérés Fondée sur une théorie du test bien établie Implémentation efficace: génération à la volée (TGV) Largement publié Transfert industriel (Telelogic)

3. Test asynchrone et test réparti testeur ?a !x ?b ?d ?c !y !z !a ?x !b !d !c ?y ?z !e !f I Contributions : Inversion de la distorsion par estampillage [JJTV-FP99] Distribution de testeur + consensus [JJKV-FP98] Problèmes : Test asynchrone : distorsion ⇒ perte d’information Test réparti : coordination concurrence

4. Génération de tests symboliques [RBJ-IFM00, CJRZ-Tacas01, CJRZ-Esmart01,CJRZ-Esec01] Motivations: Éviter l’explosion combinatoire ← données énumérées “Programmes” de test génériques (non instanciés) Approche Modèle symbolique: IOSTS (~ autres modèles similaires)  Sémantique IOLTS ⇒ théorie du test identique Génération symbolique: S , TP ∈ IOSTS  TC ∈ IOSTS Sélection par utilisation de l’interprétation abstraite [Cousot77] Exécution : Instanciation des entrées ← résolution de contraintes

Modèle IOSTS TP S t condition Constante Initiale Q symbolique Variable Price >0 TP Variable propre/observée Begin p =paid Return!(p) b = vb Deliver!(b) t paid:=0 true paid < Price Return?(m) S0 Cancel? Cancel? Empty!(b) Return Idle Reject ¬(mb=COFFEE) Deliver!(mb) Localités val(l) v > 0 Coin?(v) paid:=paid+v paid < Price ∧ d = paid - Price Return!(d) Delivery mb=COFFEE Deliver!(mb) Pay Choose?(b) vb:=b paid ≥ Price ∧ d=paid - Price Return!(d) paid:=Price Accept Cancel? paramètre de communication Choose

Sémantique [[.]]: IOSTS  IOLTS M  [[M]] Condition initiale Q k>0 ⌃ v1=0 s0 vo < k ⌃ x > 0 ⌃ (l=s0) in?(x) v1:= vo+ p; (l=s1) Garde Action(param.com.) Affectation s1 (s0,1,0,0) (s0,1,0,1) (s0,1,0,2) (s0,1,0,3) (s0,2,0,0) (s0,2,0,1) (s0,2,0,2) (s0,2,0,3) ⊨ Q in?(1) in?(2) (2,s1,2,1) (2,s1,2,0) (2,s1,2,2) (2,s1,2,3) (2,s1,3,1) (2,s1,3,0) (2,s1,3,2) (2,s1,3,3)

Génération symbolique Opérations syntaxiques dont la sémantique commute avec les opérations sur les IOLTS : Produit: xs Calcul des blocages: Ds Déterminisation: dets Vis(PS) = dets(Ds(S xsTP )) Traces([[ dets(Ds(S xsTP)) ]]) = Traces(det(D([[ S ]] xe [[ TP ]])) Sélection : reach, coreach non calculables de manière exacte ⇒ sur-approximations reacha et coreacha [[.]] [[M]] M ops op [[.]] ops(M) [[ops(M) ]] = op[[M]]

Conséquences de la sur-approximation reach(Q) ∩ coreach(Accept) [[Vis(PS) ]]  CTG Calcul exact ? ! Sur-approximation [[CTG]] ? ? Inconc reach(Q) Accept ?otherwise Fail

Exemple: calcul du produit S Price >0 Price >0 PS b=vb Deliver!(b) p =paid Return!(p) Begin Begin,s0 t paid:=0 Empty!(b) t paid:=0 Cancel? Return Idle Delivery Cancel? Return Reject Idle,s0 v > 0 Coin?(v) paid:=paid+v paid < Price ∧ d = paid - Price Return!(d) v > 0 Coin?(v) paid:=paid+v paid < Price ∧ d = paid - Price Return!(d) Idle Reject Pay Choose?(b) vb:=b Pay,s0 paid ≥ Price ∧ d =paid - Price Return!(d) paid:=Price paid ≥ Price ∧ d =paid - Price Return!(d) paid:=Price Cancel? Cancel? Choose Choose,s0 TP true Choose?(b) vb:=b Cancel? S0 ¬(b=COFFEE) ∧ b=vb Deliver!(b) paid < Price Return!(m) mb=COFFEE Deliver!(mb) Delivery,s0 b=COFFEE ∧ b=vb Deliver!(b) ¬(mb=COFFEE) Deliver!(mb) Empty!(b) Reject Accept Begin Accept Begin Reject

Sélection du graphe de test CTG Price >0 Vis(PS) Price >0 !d paid:=0 Begin,s0 ?d paid:=0 Begin,s0 Cancel? paid:=0 Cancel? !d v ≥ Price Coin!(v) paid:=v ?d Idle,s0 Return Reject Idle,s0 v > 0 Coin?(v) paid:=paid+v v > 0 Coin?(v) paid:=0+v ?otherwise v ≥ Price Coin!(v) paid:=v Pay,s0 paid < Price ∧ d = paid - Price Return!(d) Fail d =paid - Price Return?(d) paid:=Price Pay,s0 Idle Reject Cancel? paid ≥ Price ∧ d =paid - Price Return!(d) paid:=Price ?d Choose,s0 ?otherwise !d b=COFFEE Choose!(b) vb:=b Choose,s0 Choose?(b) vb:=b ¬(b=COFFEE) ∧ b=vb Deliver!(b) b=COFFEE ∧ b=vb Deliver!(b) Delivery,s0 Delivery,s0 vb=COFFEE ∧ b=vb Deliver?(b) vb= COFFEE ∧ b=vb Empty!(b) Empty!(b) Begin Accept Begin Reject Inconc Pass

Exécution: instanciation des constantes et résolution des gardes CTG Price >0 Implémentation I Price = 40 Begin,s0 ?d paid:=0 !d Résolution v ≥ Price v ≥ Price Coin!(v) paid:=v Idle,s0 Coin!(50) ?otherwise v ≥ Price Coin!(v) paid:=v Pay,s0 ?otherwise Return? (10) Fail d =paid - Price Return?(d) Fail ?d Choose!(COFFEE) Choose,s0 ?otherwise ?otherwise b=COFFEE Choose!(b) vb:=b Deliver?(COFFEE) vb= COFFEE ∧ b=vb Empty!(b) Delivery,s0 vb=COFFEE ∧ b=vb Deliver?(b) Empty?(COFFEE) Inconc Pass Pass Inconc

Outillage: STG Génération Opérations symboliques Analyse approchée par interprétation abstraite (NBAC) Exécution Compilation C++/Java Résolution de contraintes (Omega) Expérimentations : CEPS Distribution : prévue fin 2004 Specification Test purpose Génération de test NBAC dotty Test case Compilation C++/ Java Test case IUT C++/Java Omega verdict

Contributions à la génération de tests symbolique Originalité : Génération de « programmes » de test Traitement de systèmes non-déterministes Théorie indépendante de l’approximation Cadre formel : ⇒ garantie de propriétés des tests : correction, « exhaustivité » Outillage (STG) : génération et exécution Publications

5. Bilan Contribution originale à l’algorithmique de la génération de tests Techniques énumératives à la volée Techniques symboliques Non déterminisme Asynchronisme et répartition Cadre formel  propriétés des tests Outillage et expérimentations Passage à l’échelle

Travaux connexes Modèles voisins : FSM, EFSM (voir e.g. [Lee-Yannakakis 96])  contrôle et données Autres techniques à base d’objectifs : MSC [Grabowski et al 93] Utilisation de model-checkers (e.g. [Engels et al-97, Hong-Lee et al. 01])  limités dans le traitement du non-déterminisme Autres techniques symboliques : Simulation symbolique + résolution de contraintes (pb de chemins) Smile [Eertink94] TVeda [Clatin et al. 95], Agatha [Lugato et al. 02], Gatel [Marre], BZ-TT [Legeard et al] + spec algébriques [Gaudel-James99, Lestiennes-Gaudel02], Abstractions: EFSM [Petrenko et al 99-04]

Défis de la génération automatique de tests pour les systèmes réactifs Accroître l’usage industriel des méthodes formelles pour le test : ↗ qualité ↘ coûts L’automatisation du test est un levier pour une meilleure introduction des méthodes formelles dans l’industrie.  Passage à l’échelle de l’automatisation traiter efficacement des systèmes plus complexes en taille et expressivité  Méthodologies d’utilisation et de combinaison des méthodes formelles

Perspectives Accroître l’expressivité des modèles : contrôle, données, concurrence, communication, temps Améliorer les critères de sélection : objectifs, couverture, hypothèses de sélection Combiner les techniques pour la génération de tests : model-checking, preuve, analyse statique, interprétation abstraite, résolution de contraintes, ordres partiels, Combiner les méthodes de validation dans le processus de développement : Vérifications statiques, contrôle, test

Quelques travaux en cours Vérification et test de propriétés de sûreté Tester violation d’une propriété de sûreté valide sur la spécification [RMTJJ-Testcom04] Couverture en model-checking et génération de test [Hoskote et al. 99, Chockler et al. 01] Propriétés couvrantes  tests couvrants Test de robustesse Tester la préservation de propriétés de sûreté en présence d’aléas Contrôle et test Contrôler la conformité d’une implémentation [JMRT-MSR03-CDC04-IJPR04]

Fin

Systèmes infinis: détection, représentation et model-checking !b ?a !c ?b Non-bornitude Indécidable [BZ81] Décidable ds sous-classes [e.g. Fin82] Détection par CS sur files (CNS pour ss-classe + générale) Représentation du système infini par grammaire de graphes Model-checking de CTL sur grammaire de graphe [J-Stacs91, JJ-TCS93, QJ-Segragra95, QJ-FortePSTV96]

Vérification à la volée Motivation: éviter l’explosion combinatoire Spec  S  invalider P en construisant S partiellement par DFS + remplacement [Holzmann] Non-bornitude Model-checking de LTL(séq. finies) Bisimulation [FM-CAV91] [JJ-CAV89,JJ-CAV91, FJJM-FMSD93]

Observation de traces d’exécutions réparties [JJJR-ICDCS94]

Test asynchrone [JJTV-FP99] !x !y S∥F ?a !x !y S∥ST∥F ?a !x(1) !y(0) Testeur ST-1 F I ST !a ?x(1) ?y(0) TC(S∥ST∥F) ?otherw Fail ¬(I ioco S) ¬(I∥ST∥F ioco S||ST|| F) ?y ?otherw !a ?x TC(S) Fail ?a !y I∥F ioco S∥F ?a !y(1) ?a !y

Distribution de test pour le test réparti [JJKV-FP98] consensus distribué TC 1 3 2 !A ?C ?B Comm. asynchrone Pb choix non-local T1 T2 IUT TC1 TC2 1 1’ 1’’’ 2’ !A !vote(B) T2!B T2!A 1’’ 3 ?elu(B) ?elu(C) 2’’ ?B 1 !vote(C) T1?B T2?A 2 1’ ?elu(B) ?elu(C) ?C 1’’ 3 coordination T3 Approche par modèle de la concurrence [Jard02]

Vérification visuelle: dessin 3D de graphes d’états [J-GD94,J-Cfip94] Représentation des informations sémantiques processus actif concurrence Propriété s s’  coord(s) coord(s’)

Travaux en cours Couverture en model-checking / test pour S ⊨ y, s couvert si mutant(S,s) ⊭ y couverture structurelle ↔ MdF sur FSM couverture de dépliage ↔ MdF sur Traces, ioco S ⊨ y, s couvert pour y, q ssi Ssq¬q ⊭ y Test de robustesse Test de programmes à virgules flottantes

Systèmes réactifs et répartis Exemples: protocoles, systèmes embarqués, etc. Env communication synchrone/asynchrone P1 P2

Relation de conformité I ioco S ≜ ∀ s ∈ STraces(S), Out(D(I) after s) ⊆ Out(D(S) after s) ?A ?B ! Z ! Y i ! X S D(S) !d ?A ?B ! Z ! Y i ! X D(I1) non-conforme livelock sortie non-spécifiée ?A i ?B ! Z ! X I2 conforme choix d’implémentation spec. partielle

Exemple de génération * Comportements visibles Calcul des blocages CTG TC ?A ?B !Z !Y i !X det(D(S)) ?B ?A !Y !X !Z !d Accept det(D(S))xTP S ?A ?B !Z !Y !X !d ?d !B !A ?Y ?X !B ?Z ?d Pass Inconc D(S) Fail ?other !d !d !z * Accept !x TP Comportements visibles STraces(S)=Traces(D(S)) Calcul des blocages Intersection de comportements acceptés STraces(S)  TracesAccept(TP) Objectif de test Traces(TP)=(Sd)* TracesAccept(TP) Sélection: pb de vérification reach(Init)  coreach(Accept) Inversion entrées/sorties Complétion  Fail Conflits de controlabilité

Principe de la génération de tests à la volée ?B !Z !Y i !X TC/CTG det(D(S)) det(D(S))xTP S ?A ?B !Z !Y !X !d D(S) ?B ?A !Y !X !Z !d Accept Inconc Fail !A ?Y ?X !B ?Z ?d Pass ?other !z * Accept !x TP

Principes de la génération TP S! d ⋃ S? CTG S=[[Spec]] D(S) TC Spec det(D(S)) det(D(S))xTP Spec Spec TestP + var, loc S=[[Spec]] TP S! ⋃ S? ⋃ St Spec xsTestP SxiTP SP=[[Spec xsTestP]] D(SxiTP) D(SP) det(D(SxiTP)) det(D(SP)) CTG CTG TGV Agedis TC TC TGV

Extension aux objectifs de sûreté [RMTJJ-Testcom04] y propriété de sûreté sur Straces(S).S! Vérifier S ⊨ y Tester la violation de y par I Lien entre vérification et test I ioco S ⇔ ∀y ∈ p(S), S ⊨ y  I ⊨ y Génération de tests sur det(D(S)).S! x w¬y Verdicts des cas de tests: Violate  y violée Fail  non-conformité  j violée Inconc  not (reach(¬y ∧ ¬ ioco)) Vérification S ⊨ P Test not(I conf S) ? I ⊭ P ? P S I

Extension aux propriétés de sûreté [Testcom04] S ⊨ y sûreté , tester la violation de y par I, I ⊭ y I ioco S ⇔ ∀y ∈ pertinente(S), S ⊨ y  I ⊨ y Propriété j accessibilité sur STraces y sûreté sur STraces Objectif TPj  TracesAcc(TPj) Obs¬y TracesVl(Obs¬y) Vérification S ⊨ j STraces(S) ⋂TracesAcc(TPj)≠⌀ S ⊨ y STraces(S) ⋂TracesVl(TP¬y)=⌀ Génération det(D(S)) x TPj reach(init) ⋂ coreach(Acc) Pass, Inconc, Fail det(D(S)).Sd! x TP¬y reach(init) ⋂ coreach(Vl) Violate, Inconc, Fail

Test et contrôle Contrôle : S ⊭ y  construire C tq S ∥ C ⊨ y Similitude avec génération de tests (reach ⋂ coreach)  synthèse de contrôleur (accessibilité) dans TGV Contrôle pour de la conformité S et I connues, assurer I ioco S par contrôle Observation totale Observation partielle [JMRT-MSR03-CDC04-IJPR04]

Panorama des techniques existantes Modèle Spec S + Hyp FSM [Lee-Yan] s - i/o-> s’ (IO)LTS [Tretmans] s-?i->s’ –t -> s” -!o-> s”’ Spec. algébriques [Bernot -Gaudel] sort/op/axiom IUT inconnue I interface coonue hyp: ∃ modéle I ∈ MdF (fini) sortie/transfert I ∈ (IO)LTS I ⊨ Hyp unif, reg, etc Conformité/Modèle de fautes IUT sans faute/MdF (IUT ≈traces S ) ioco STr(I) ⋂ Str(S).S! ⊆ STr(S) I ⊨ Axiomes Cas de tests Séquences --> s –i/o->s’ + check(s’) Instance d’axiome ds I Génération TT, DS, UIO,W… opt: voyag. comm. Sélection (non-det, obj) sous-IOLTS de vis(S) Dépliage termes Propriétés Correct: rejet  ┐conf Exhaust: ┐conf  rejet correct exhaust / MdF “exhaust.” (TS infinie) exhaust /Hyp Extensions Ctrl + data EFSM IOSTS Spec. alg + IOLTS

Shéma général de la génération de tests symboliques IOSTS S [[S]] IOLTS [[ . ]] TP [[TP]] xs xe [[ . ]] PS = S xs TP [[S xs TP]] = [[S]]xe[[TP]] Ds D [[ . ]] PS D = Ds(PS) [[Ds(PS)]] = D [[PS ]] dets = subsets ◯ es det = subset ◯ e [[ . ]] PSvis = dets(PS D ) Tr(Acc)[[dets(PS D) ] = Tr(Acc)(det[[PS D]]) select selects Tr[[selects(PSvis) ]] ⊇ Tr(select [[PSvis]]) TrP[[selects(PSvis) ]] = TrP(select [[PSvis]]) TrF[[selects(PSvis) ]] ⊇ TrF(select [[PSvis]]) [[ . ]] CTG = selects(PSvis)

Déterminisation: heuristique G1∧ ¬G2 a(p) A1 l G2∧¬G1 a(p) A2 l G1 a(p) A1 G2 a(p) A2 G1∧ G2 a(p) ma :=p l1 l2 l1 l2 G’1 b(r) A’2 G’2 c(l) A’2 G’1 b(r) A’1 G’2 c(l) A’2 l1,l2 G’1◯ A1(p/ ma) b(r) A’1◯ A1(p/ ma) G’2◯ A2(p/ ma) c(l) A’2◯ A2(p/ ma) l’1 l’2 l’1 l’2

Produit QS QTP QS ^ QTP VoTP = VpS GS(C,LS,VpS,pS) a(pS) (LS,VpS) :=AS(C,LS,VpS,pS) s0 tp0 GTP(C,LTP,VpTP,VoTP,pTP) a(pTP) (LTP,VpTP) :=ATP(C,LTP,VpTP,VoTP,pTP) s1 tp1 QS ^ QTP s0,tp0 GS(C,LS,VpS,pS) ^ GTP(C,LTP,VpTP,VoTP,pTP/pS) a(pTP) (LS, LTP,VpS,VpTP) :=AS(C,LS,VpS,pS) ⋃ ATP(C,LTP,VpTP,VoTP,pTP/pS) S1,tp1

Produit S PS TP t t Price >0 Price >0 b=vb Deliver!(b) p =paid Return!(p) Begin Begin,s0 t paid:=0 Empty!(b) t paid:=0 Cancel? Return Idle Delivery Cancel? Return Reject Idle,s0 v > 0 Coin?(v) paid:=paid+v paid < Price ∧ d = paid - Price Return!(d) v > 0 Coin?(v) paid:=paid+v paid < Price ∧ d = paid - Price Return!(d) Idle Reject Pay Choose?(b) vb:=b Pay,s0 paid ≥ Price ∧ d =paid - Price Return!(d) paid ≥ Price ∧ d =paid - Price Return!(d) Cancel? Cancel? Choose Choose,s0 TP true Choose?(b) vb:=b Cancel? S0 ¬(b=COFFEE) ∧ b=vb Deliver!(b) paid < Price Return!(m) mb=COFFEE Deliver!(mb) Delivery,s0 b=COFFEE ∧ b=vb Deliver!(b) ¬(mb=COFFEE) Deliver!(mb) Empty!(b) Reject Accept Begin Accept Begin Reject

Blocages et e-clôture PS PSvis !d t !d !d !d !d !d !d Price >0 Begin,s0 !d paid:=0 Begin,s0 t paid:=0 Cancel? paid:=0 Cancel? !d Cancel? Return Reject !d Idle,s0 Idle,s0 Return Reject v > 0 Coin?(v) paid:=paid+v v > 0 Coin?(v) paid:=0+v v > 0 Coin?(v) paid:=paid+v paid < Price ∧ d = paid - Price Return!(d) paid < Price ∧ d = paid - Price Return!(d) false !d Idle Reject Pay,s0 Pay,s0 Idle Reject Cancel? paid ≥ Price ∧ d =paid - Price Return!(d) paid ≥ Price ∧ d =paid - Price Return!(d) Cancel? !d Choose,s0 !d Choose,s0 false !d Choose?(b) vb:=b Choose?(b) vb:=b b=COFFEE ∧ b=vb Deliver!(b) ¬(b=COFFEE) ∧ b=vb Deliver!(b) ¬(b=COFFEE) ∧ b=vb Deliver!(b) Delivery,s0 Delivery,s0 b=COFFEE ∧ b=vb Deliver!(b) Empty!(b) Begin Accept Empty!(b) Begin Accept Begin Reject Begin Reject

Sélection: reach (approx.) + S?  Reject Price >0 PSvis Price >0 !d paid:=0 !d paid:=0 Cancel? paid:=0 Begin,s0 Begin,s0 v > 0 Coin?(v) paid:=v Cancel? !d !d Idle,s0 Return Reject Idle,s0 v > 0 Coin?(v) paid:=paid+v v > 0 Coin?(v) paid:=0+v v > 0 Coin?(v) paid:=v paid < Price ∧ d = paid - Price Return!(d) paid < Price ∧ d = paid - Price Return!(d) Pay,s0 Idle Reject Pay,s0 Idle Reject Cancel? paid ≥ Price ∧ d =paid - Price Return!(d) paid ≥ Price ∧ d =paid - Price Return!(d) d d Choose,s0 Choose,s0 Choose?(b) vb:=b Choose?(b) vb:=b ¬(b=COFFEE) ∧ b=vb Deliver!(b) ¬(b=COFFEE) ∧ b=vb Deliver!(b) b=COFFEE ∧ b=vb Deliver!(b) Delivery,s0 b=COFFEE ∧ b=vb Deliver!(b) Delivery,s0 Begin Accept Empty!(b) Begin Reject Empty!(b) Begin Accept Begin Reject

Sélection: coreach (approx.) Price >0 Price >0 !d paid:=0 !d paid:=0 Begin,s0 Begin,s0 v > 0 Coin?(v) paid:=v v > 0 ∧ v ≥ Price Coin?(v) paid:=v !d !d Idle,s0 v > 0 ∧ v ≥ Price Coin?(v) paid:=v Idle,s0 v > 0 Coin?(v) paid:=v paid < Price ∧ d = paid - Price Return!(d) Pay,s0 paid < Price ∧ r_v = paid - Price Return!(d) Idle Reject Pay,s0 paid ≥ Price ∧ d =paid - Price Return!(d) paid ≥ Price ∧ d =paid - Price Return!(d) Idle Reject !d Choose,s0 d Choose,s0 Choose?(b) vb:=b b=COFFEE Choose?(b) vb:=b ¬( b=COFFEE) ∧ b=vb Deliver!(b) Delivery,s0 b=COFFEE ∧ b=vb Deliver!(b) ¬( b=COFFEE) ∧ b=vb Deliver!(b) b=COFFEE ∧ b=vb Deliver!(b) Delivery,s0 Empty!(b) Begin Accept Begin Accept Empty!(b) Begin Reject Begin Reject

Sélection: reach (approx.) + inversion i/o + fail Price >0 CTG Price >0 !d paid:=0 Begin,s0 ?d paid:=0 Begin,s0 v > 0 ∧ v ≥ Price Coin?(v) paid:=v !d !d v > 0 ∧ v ≥ Price Coin?(v) paid:=v Idle,s0 v ≥ Price Coin!(v) paid:=v Idle,s0 ?otherwise v ≥ Price Coin!(v) paid:=v Pay,s0 paid < Price ∧ d = paid - Price Return!(d) Pay,s0 paid ≥ Price ∧ d =paid - Price Return!(d) Fail d =paid - Price Return?(d) Idle Reject d Choose,s0 ?d Choose,s0 b=COFFEE Choose?(b) vb:=b b=COFFEE Choose!(b) vb:=b ¬( vb=COFFEE) ∧ b=vb Deliver!(b) vb=COFFEE ∧ b=vb Deliver!(b) b=COFFEE Deliver?(b) Delivery,s0 b= COFFEE Empty!(b) Delivery,s0 Begin Accept Begin Accept Begin Reject Empty!(b) Inconc

Approche Passage à l’échelle Méthodes formelles pour le test et la vérification Modèles et théories Algorithmique Outillage : prototype  transfert Expérimentations Enseignement/Formation Passage à l’échelle

Modèle IOSTS S TP t k >0 in ? (x) v1:=x v1 < 0 nok!() true condition Initiale Q Constante symbolique ~ variable k >0 s0 TP in ? (x) v1:=x Variable propre/observée v1 < 0 nok!() true s1 t0 v1 >= 0 t v2:=v1- k 0 ≤v2 ≤ 2 out!(z) alert!() v2=0 alert!() y = v2 out!(y) nok!() Action & paramètre de communication Reject Accept s2 Localité ~ variable énumérée

Résultat sur l’exemple k >0 k x=v1 x=k, alert? x=k+2 out(x-k) s0 in ? (x) v1:=x v1 < 0 nok!() y = v2 out!(y) s1 v1 ≥ 0 t v2:=v1- k v2=0 alert!() k >0 TC tc0 k ≤ x ≤ k+2 in ! (x) v1:=x s2 TP true ?otherwise Fail tc1 t0 y = v1 – k ∧ 0≤ y ≤ 2 out ? (y) v1=k alert ? () 0 ≤v2 ≤ 2 out!(z) alert!() Inconc Pass nok!() Reject Accept