Corrigé LI5a: Développement de programmes

Corrigé
Licence Info
LI5a: Développement de programmes
(A. Slissenko)
Examen du 08 Juin 2004,
14h–18h
1 [2 points]. Quelles considérations prend-t-on en compte pour construire un jeu de tests?
Trouver un jeu de tests qui couvre le programme suivant (le symbole ”;” signifie la composition
séquentielle):
If |x| = 2 ∧ |y| = 3 Then Return 0 EndIf ;
If |x| = 2 Then Return (y 2 − 9) EndIf ;
z := x2 ; u := (z − 4)(x + 2) − (z − y 2 + 5); Return u
Quelle fonction calcule ce programme ?
Réponse à 1:
Pour construire un jeu de tests on prend en compte des considérations sémantiques fondées sur
notre compréhension du problème, et des considérations fondées sur la structure du programme. Les
premières nous disent qu’il faut avoir des tests qui vérifient les cas typiques et les cas marginaux de
l’ensemble de situations; les deuxièmes nous disent que nos tests doivent couvrir le programme et
doivent exécuter les branches du programme les plus importantes du point de vue des spécifications.
Pour le programme donné un jeu de tests qui le couvre est le suivant: (x, y) = (2, 3), (2, 0), (0, 0).
Le programme calcule la fonction f (x, y) = (x2 − 4)(x + 2) − (x2 − y 2 + 5).
************************************************************************************
2 [6 points]. Décrire un diagramme de cas d’utilisation et un diagramme de classes pour un programme
qui gère les ventes d’eaux minérales. Il y a plusieurs sources qui fournissent des eaux de types différents
(on n’exclut pas le cas où un type d’eau est fourni par plusieurs sources, mais le type d’une source est
toujours le même). Une source peut être capable de produire une quantité donnée d’eau ou non, cela
dépend de sa capacité. Les commandes d’eau son faites par des grossistes qui demandent une quantité
d’eau d’un certain type. Le programme doit traiter les commandes et gérer la livraison qui a aussi des
capacités limitées. De plus le programme doit planifier l’entretien systématique des sources.
Votre diagramme de classes doit avoir 4 classes et pour chaque classe — 2 attributs et 2 opérations.
Choisissez les classes, atributs et opérations les plus importants de votre point de vue. Pour le
diagramme de cas d’utilisation choisissez 4 cas d’utilisation.
Réponse à 2:
Le texte indique que le programme doit gérer les commandes de grossistes, les livraisons et
l’entretien de sources. Donc, on peut introduire les classes: CommandeEau, Livraison, Entretien.
Comme 4ème classe on peut prendre soit Grossiste, soit Livreur, soit Source.
Un diagramme de classes possible:
r
eidon fo
s
o
P
ity Editio
n
n
u
io
m
it
m
d
s
Co
yE
ition Po
r UML,
mmunit
d
o
f
o
E
C
n
y
,
o
io
it
L
n
id
mmu
Pose
for UM
nity Edit
n
u
n
o
io
m
it
id
m
d
ML, Co
e
o
E
s
,C
Po
ity
for UML
ommun
Edition
C
n
y
,
o
it
L
n
id
u
M
e
s
U
o
y Editi
r
mm
P
it
o
f
o
n
n
u
C
n
,
o
io
m
L
it
id
m
CommandeEau Pose
Livraison
UM
Co
y Ed
ition
r UML,
mmunit
d
o
f
o
E
C
n
y
,
o
it
L
−
idCommandeEau:String
−
idCommandeLivrsn:String
n
id
Pose
for UM
ommu +typeEau:String
nity Edit
n
u
C
n
,
o
io
m
L
it
id
+etatCmdLivrsn:String
m
d
M
e
o
E
s
U
,C
Po
ity
for UML
ommun
Edition
C
n
y
,
o
it
L
n
+creerCmdEau():void
+creerCmdLvrsn():void
id
u
M
e
s
omm +archiverCmdEau():void seidon for U+archiverCmdLvrsn():void Edition Po
unity Ed
m
m
o
UML, C
C
o
y
L,
nit
n P
Commu
n for UM
y Editio
,
o
it
L
n
id
u
M
e
Ed
s
U
m
o
r
*
Com
ion P
munity
it
idon fo
m
d
e
o
E
s
C
o
y
r UML,
,
P
it
L
UM
ion
mun
L, Com
nity Edit
idon for
u
M
e
s
U
m
o
r
m
P
ity E
o
f
o
,C
dition
eidon
ommun
E
s
C
o
y
,
P
it
or UML
L
n
n
u
M
itio
rU
mm
unity Ed
ML, Co
eidon fo
E
s
U
m
o
r
m
P
o
f
o
n
C
n
,
io
munity
it
ido
m
d
e
o
E
s
C
o
y
,
P
it
or UML
n
un
ML
or U
y Editio
, Comm
on for Uion Poseidon f ity
itGrossiste
L
n
Entretien
id
u
M
e
s
U
m
o
r
m
P
o
n
un
nf
Edit
, Co −idGrossiste:String
−idSource:String
Poseido
ity EditioL, Community or UML, Comidmon for U
for UML
n
n
u
io
m
it
m
d
se
UM
Co
nf
+nbCmdEau:int[
−dateEntretien:String
unity E ]
r UML, Poseidon for ition Poseidonity Edition Po mmunity
mm
o
f
o
C
n
,
o
L
id
n
u
d
Co
r
+ajouterGrossiste():void n Pose
y Editio ommunity Er UML, Comm
n for UM
itio
r UMnL,Poseidon fo
unit+creerCmdEntretien():void
d
o
m
f
E
m
C
n
o
y
f
o
,
o
it
+supprimerGrossiste():void
+creerCmdAudit():void
L
C
n
n
id
,
L
ido
UM
mu
Posemunity Editio
noitry
mu
L, ComPoseidon for UM Poseidon foitry Edition Pose nity Edition, C
m
M
o
m
U
o
C
r
,
n
o
L
o
f
L
Mn Poseid f
n
fordU
for UM
Edition munity EditioUnML, Commun UML, Comsmeu
n
n
y
o
o
io
it
it
id
n
id
e
u
s
E
Unm
diagramme de cas
o
r
r d’utilisation possible:
mm
Poommunity
nfoit
ioLn, C
midmou
ditM
ML, Cioon Poseidon fo n Poseidonunfoity Edition P
o
E
n
U
C
y
r
,
it
o
L
f
n
e
u
M
s
n
U
m
o
for
mm
ditioUML, Com
for U n Po
n
ity Edit
unityoE
MitLio, nCoPoseidon
emiduo
y Editio
r
s
U
m
it
o
o
f
ommun
r
n
m
P
o
n
f
o
n
C
n
id
o unity Ed
ioL, Com
se
idm
midm
n nfo
ML, ition PoInfoSurLesGrossistes
o
ou
ErdUitM
C
ose
y
,
e
P
it
L
s
n
o
n
u
M
m
P
d
o
on fournU
U
f
io
o
m
E
it
r
n
fo io
ity
Ed
L, C
Lio, nCoPm
oseidon
M
omm
semiduo
nitny Edit
U
mousneitidyon for UM
om
r
mP
P
o
f
o
it
d
n
C
n
o
E
,
o
io
C
L
y
it
idmunit
M
se
n
oC
oseidon
P
itnyfoErdUML,
fournU
m
n
P
o
n
u
nm
n
io
m
,
o
io
doom
it
ity Editio
L
m
it
d
id
d
o
M
E
, C ose
ity E
M
C
mousneitidyon for U << extend >> on foitry U
mP
ditLion P
o
ommun
E
C
C
,
,
L
L
n
id
n
u
M
M
e
somm
U
oseidon
itio
rU
o
r
P
d
o
P
f
o
E
f
n
C
n
n
y
n
,
o
io
it
o
L
io
it
n
id
d
Edit UM
ose
y Ed
Commu
mousneitidyon for
mmunit
dition P
o
E
m
C
o
y
,
P
it
C
L
n
idon
,
n
u
M
GestionCommandesEau
MELditio
rnU
n Pose
Comm
n for U
o
y
f
,
o
io
it
L
it
id
n
d
u
M
e
o
E
s
U
m
id
o
y
r
eCom
mmunit
dition P
eidon fo
r UML
eidon fo
, Com
o
E
ido
Grossiste
UML, C
ion Pos
munity
it
r
m
d
o
f
o
E
n Pose
C
n
y
,
o
io
it
L
it
n
id
d
u
M
e
E
s
U
m
o
<< include >> n P
for << include >>
unity
, Com
oseidon
y Editio
, Comm
P
it
L
n
n
u
M
U
io
m
it
r
m
Poseido
fo
n
Co
n
y Ed
,
o
io
it
L
it
n
id
d
u
M
e
E
s
U
m
for
nity
n Po
L, Com
seidon
Commu
oGestionEntretiens
y Editio
,
P
it
L
n
n
u
M
GestionLivraisons
U
io
m
it
r
Poseid
fo
om
Ed
n
C
n
y
,
o
io
it
L
it
n
id
d
u
M
e
E
s
U
m
for
nity
n Po
L, Com
Livreur
Commu
oseidon
y Editio
,
P
it
L
n
n
u
M
seid
U
io
m
it
L, Com
ition Po
nity Ed
idon for
d
u
M
e
E
s
U
m
o
y
r
m
P
it
o
f
o
n
ition
idon
mmu
ML, C
************************************************************************************
n Pose
unity Ed
ML, Co
se
U
io
m
it
r
m
d
o
f
o
E
C
n
L,
ition Po
nity
ido
d
u
M
e
E
s
U
m
o
y
r
m
P
it
o
f
o
n
u
n ASM en utilisant seulement
ition
ML, C
3 [6 points].
oseidoune
, Comm en parallèle
Lexécutés
n PDécrire
unity Ed des If-Then-opérateurs
M
U
io
m
it
r
m
d
o
f
o
E
C
ity contrôler le travail suivant
L,
sur PNosprocesseurs.
Votre ASM doit gérer N
eidon
mmunpour
n
n for UMde lancement deytâches
o
io
it
id
d
ML, Co
e
E
s
o
P chacun peut être soit occupé
processeurs
soit
nit libre. Cet état est géré par la machine à l’aide d’une
ndont
Commu
,processeurs
ity EditFioree (initialementotous
L
n
u
M
U
m
fonction
les
sont libres). La machine reçoit des tâches à lancer via
r
m
o
eidon f
s
UML, C
o
P
n
N entrées
T ask correspondant aux processeurs, la valeur de chacune de ces entrées est soit undef soit
io
nity Edit
muun
m
o
objet
à
traiter (par exemple un objet peut être une instance d’un problème d’optimisation); undef
C
,
UML
veut dire qu’il n’y a pas de tâche. Ayant reçu une tâche sur une certaine entrée, la machine l’envoie
au processeur si il est libre, sinon elle attend et ne regarde pas les autres tâches de cette entrée. Pour
lancer une tâche la machine affecte la valeur vrai à la fonction Launch pour cette tâche. Lorsque le
processeur termine la tâche il retourne la valeur vrai pour la fonction Done qui peut être utilisée par
l’ASM comme une entrée.
Décrire un diagramme Statechart (Etats-Transitions) pour 2 processeurs.
Réponse à 3:
Sortes:
• P=df {1, . . . , N } (processeurs)
• T askInstance (une sorte abstraite pour les tâches)
Fonctions:
• T ask : P → T askInstance ∪ {undef } (entrée)
• Done : P → Bool (entrée)
• F ree : P → Bool (sortie)
• Launch : T askInstance × P → Bool (sortie; Launch(T ask(x), x) signifie qu’on lance la tâche
T ask(x) sur le processeur x)
• α : P → T askInstance (internal function qui sauvegarde la valeur courante de T ask)
ASM:
Initialisation: T ask(x) = undef , F ree(x) pour tout x ∈ P.
om
,C
ForAll x ∈ P Do
for UML
n
o
id
e
s
Po
If T ask(x) 6= undef ∧ F ree(x) Then [Launch(T ask(x), x) := true, F ree(x)
ionf alse,
m
Edit:=
y
it
n
u
ML, Co
U
m
α(x) := T ask(x)]
r
m
o
f
o
C
n
,
Poseido
for UML
If Done(x) Then [F ree(x) := true, Launch(α(x),
Edition
Co
oseidon x) := f alse]
dition P
y
mmunit
,
or UML
f
L, Co
ici [... , ... , ...] o
est
composition
duMcours).
unity E parallèle (la notation
seidon
U
m
o
r
m
P
o
f
n
C
n
,
o
io
L
seid
Co
y Edit
n for UM
ition Po
r UML,
idoDiagramme
mmunit
d
o
e
f
o
E
s
C
n
o
y
,
o
d’états
pour
deux
processeurs:
P
it
L
n
id
u
M
e
ition
, Comm
on for U
ion Pos
eid
Edit
UML
,C
ion Pos
munity
it
idon for
m
d
e
for UML
o
E
s
C
n
o
y
,
o
P
it
L
n
id
n
u
M
e
s
U
io
m
Po
dit
om
NonFree1 idon for
Edition
UML, C
ose
y
r
,C
P
it
o
f
n
n
u
n
o
io
m
it
d
eid
for UML
om
E
s
C
n
o
y
,
o
P
it
L
n
id
n
u
M
e
s
Po
ditio
for U
omm
Edition
seidon
UML, C
o
y
r
P
it
o
f
n
n
u
n
o
UML,
io
m
Done1
Free1
eid
om
s
C
Init1Edit Task1
Launch1
Proc1Freeidon for
o
y
,
P
it
L
n
n
u
M
e
rU
mm
Editio
ion Pos ||
ML, Co
eidon fo do/Free1:=false || unity Editdo/Free1:=true
s
U
o
r
,
P
o
f
n
n
Launch1(Task1)
Launch1(Task1):=false for UML
Comm
n
oseido
y Editio
,
o
P
it
L
n
id
n
u
M
e
s
U
io
m
o
it
r
Ed
n P
Com
n fo
NonFree2 oseido
y Editio
r UML,
P
it
o
f
n
n
u
n
o
io
m
it
id
m
d
for UML
E
se
Co
n
o
y
,
o
P
it
L
n
id
n
u
M
e
s
U
io
m
Po
for
om
Edit
Edition
UML, C
oseidon
y
r
P
it
o
f
n
n
u
n
o
io
m
it
r UML
Free2
d Task2
eid
om Done2
E
s
C
o
y
Init2
Launch2
Free2 eidon fo
,
P
it
L
n
n
u
M
s
o
for U
omm
y Editio
dition P ||
seidon do/Free2:=false || munity Edo/Free2:=true
UML, C
o
r
P
o
f
n
n
o
io
Launch2(Task2)
Launch2(Task2):=false n for UM
, Com
Poseid
ity Edit
L
n
ido
n
u
M
U
io
m
it
r
m
d
o
n Pose
Co
nf
,
ty E
o
io
L
it
id
d
M
e
E
s
U
o
y
for
nit
n P
Commu
n for UM
oseidon
y Editio
,
o
P
it
L
n
id
n
u
M
e
s
U
io
m
o
it
r
P
Ici F reeJ, N onF
sont desfogardes; T askJ et DoneJ dsont
ity Ed
L, Co(Jm= 1, 2) sur les flêches
E itiondes entrées
UMreeJ
oseidon
yflêche.
r on
P
it
o
f
n
n
u
n
o
io
m
it
rU
id
”trigger”.
Ici
n’utilise
pas
α
car
la
valeur
de
T
askJ
est
la
valeur
saisie
sur
la
m
d
n Pose
unity E
ML, Co
eidon fo
s
U
io
m
o
it
r
m
P
d
o
f
o
E
n
C
n
L,
itio
nity
ido
n Pose
unity Ed
n for UM
************************************************************************************
o
U
io
m
it
id
m
d
e
o
E
s
C
o
y
L,
nit
idon for
n P
u
M
e
s
U
io
m
o
it
r
m
P
d
o
f
o
E
nity
Edition en parUML, C
oseidon des If-Then-opérateurs
Pseulement
forDécrire
nity exécutés
4 [6 e
points].
une ASM (en utilisant
n
u
n
o
io
m
it
id
m
d
o
E
s
C
, sortie F eu) qui sont numérotés
on for U
Po qui effectue le changement
ity couleurs de N feux (fonction
L
n
id
n
u
M
e
s
U
io
m
o
it
r
allèle)
des
de
m
P
d
o
on f
L, Co
ition
unity E
seidjaune
r UM
Posoit
ity Edreçoit
n
n
u
{0, o
1,s.e. id
. ,o
Nn−fo1}.
Chaque feu peut y
être
soit
vert
soit
rouge.
La
machine
un seul
io
m
it
m
d
for
o
P
L, C
nsignal
unit ,Evert, rouge, jaune.n fSi
M
seidon
U
io
m
o
it
r
m
P
d
o
o
E
Switch
avec
les
valeurs
undef
le
signal
est
jaune
alors
la
machine
n
C
y
,
o
io
dit
ML
seid
munit
Povert
ity E
unn’y
n for U(avec
ionfeu
m
it
id
cherche
le opremier
le plus petit
numéro)
et
le
passe
au
jaune.
S’il
en
a pas, alors
m
d
e
o
E
s
C
o
y
,
P
it
n
un
ML
U
io
m
it
r
m
d
o
f
o
E
C
n
,
elle cherche le premier
au jaune.
ido elle ne fait rien. Le signal vert passe le
munity
PoseSinon
or UMLfeu rouge et le passe
n fait
n fau
o
io
it
id
d
e
E
s
premier
rouge
vert;
s’il
n’y
en
a
pas
–
elle
ne
rien.
Pareil pour le rouge qui change le premier
o
y
ition P
mmunit
d
o
E
C
y
,
it
L
n
vert
en
jaune,
sinon
–
rien.
mu
r UM
eidon fo
s
o
P
n
y Editio
mmunit
Réponse à 4:
Sortes:
• F eux = {0, 1, . . . , N − 1}; cette sorte est considérée comme sous-sorte de N. Donc on peut
utiliser les relations et fonctions mathématiques standards pour les nombres naturels, par example,
min.
• Couleurs = {vert, rouge, jaune}
Fonctions:
• Switch :→ Couleurs ∪ {undef } (entrée)
• F eu : F eux → Couleurs (sortie)
ASM:
Initialisation: Switch = undef , F eu(x) est arbitraire pour x ∈ P.
If Switch = jaune ∧ ∃ x F eu(x) = vert Then F eu(min{x : F eu(x) = vert}) := jaune
If Switch = jaune ∧ ¬ ∃ x F eu(x) = vert ∧ ∃ x F eu(x) = rouge
Then F eu(min{x : F eu(x) = rouge}) := jaune
If Switch = vert ∧ ∃ x F eu(x) = rouge Then F eu(min{x : F eu(x) = rouge}) := vert
If Switch = rouge ∧ ∃ x F eu(x) = vert Then F eu(min{x : F eu(x) = vert}) := jaune
On suppose (par défaut) que Switch reste inchangé suffisamment longtemps pour que la machine
ci-dessus puisse exécuter une fois un opérateur If-Then.
Si vous voulez expliciter la recherche des numéros min{x : F eu(x) = vert}, min{x : F eu(x) = rouge}
if faut imposer une contrainte plus forte: Switch ne change pas pendant cette recherche. Mais la
spécification ne demande pas de détailler cette recherche.
************************************************************************************