Modularité, tests unitaires et documentation en Pascal. as Architecture des Systèmes d Information. I3 - Algorithmique et programmation

(1)

Modularit´ e, tests unitaires et documentation en Pascal

I3 - Algorithmique et programmation

Nicolas Delestre

(2)

Architecture des Systèmes d’Information

as Plan

1

Modularit´ e

2

Tests unitaires

3

Documentation

4

Puissance 4

D´ ecoupage du programme en unit´ es Cr´ eation des tests unitaires

Ajout de la documentation Compilation

Qualit´ e du programme

5

Conclusion

(3)

Constats

La programmation structur´ ee facilite la r´ eutilisabilit´ e

Par exemple pour le d´ eveloppement du programme de chiffrement de Vigen` ere vu en I2, vous avez r´ eutilis´ e certaines fonctions provenant du programme de chiffrement de C´ esar

Mais pour l’instant en Pascal, nous avons r´ eutilis´ e des

fonctions/proc´ edures dans diff´ erents programmes en faisant un

copier/coller

. Ce n’est pas satisfaisant car :

on duplique du code (une future erreur sera ` a corriger n fois) on risque d’ajouter de nouvelles erreurs

Il faudrait pouvoir inclure des types et/ou des sous-programmes (fonctions/proc´ edures) dans un programme

C’est le rˆ ole des Unit´ es Pascal (unit)

(4)

as Cr´ eation d’une unit´ e pascal 1 / 4

Structure d’une unit´ e (fichier .pp ou .pas)

u n i t nom ; i n t e r f a c e

{ i n c l u s i o n d ’ a u t r e s u n i t ´e s P a s c a l +

types , c o n s t a n t e s et s i g n a t u r e s d e s sous - p r o g r a m m e s p r o p o s ´e s p a r l ’ u n i t ´e ( p u b l i q u e s ) }

i m p l e m e n t a t i o n

{ i n c l u s i o n d ’ a u t r e s u n i t é s P a s c a l + t y p e s p r i v é s , c o n s t a n t e s p r i v é e s et sous - p r o g r a m m e s p u b l i q u e s et p r i v é s ) [ i n i t i a l i z a t i o n

{ C o d e e x é c u t é au c h a r g e m e n t de l ’ u n i t é } ]

end.

(5)

Cr´ eation d’une unit´ e pascal 2 / 4

Exemple

1u n i t c o m p l e x e ; 2

3i n t e r f a c e 4

5 t y p e

6 T C o m p l e x e = r e c o r d

7 re : R e a l;

8 im : R e a l;

9 end;

10

11 f u n c t i o n c o m p l e x e ( p a r t i e R e e l l e , p a r t i e I m a g i n a i r e : R e a l) : T C o m p l e x e ;

12 f u n c t i o n p a r t i e R e e l l e ( z : T C o m p l e x e ) : R e a l; 13 f u n c t i o n p a r t i e I m a g i n a i r e ( z : T C o m p l e x e ) : R e a l; 14 f u n c t i o n c o m p l e x e E n C h a i n e ( z : T C o m p l e x e ) : S t r i n g ;

(6)

as Cr´ eation d’une unit´ e pascal 3 / 4

1i m p l e m e n t a t i o n 2

3 c o n s t N B _ C H I F F R E S _ A P R E S _ V I R G U L E = 2;

4

5 f u n c t i o n c o m p l e x e ( p a r t i e R e e l l e , p a r t i e I m a g i n a i r e : R e a l) : T C o m p l e x e ;

6 v a r r e s u l t a t : T C o m p l e x e ; 7 b e g i n

8 w i t h r e s u l t a t do

9 b e g i n

10 re := p a r t i e R e e l l e ; 11 im := p a r t i e I m a g i n a i r e ; 12 end;

13 c o m p l e x e := r e s u l t a t 14end; { c o m p l e x e } 15

16 f u n c t i o n p a r t i e R e e l l e ( z : T C o m p l e x e ) : R e a l; 17 b e g i n

18 p a r t i e R e e l l e := z . re ; 19end; { p a r t i e R e e l l e }

(7)

Cr´ eation d’une unit´ e pascal 4 / 4

1 f u n c t i o n p a r t i e I m a g i n a i r e ( z : T C o m p l e x e ) : R e a l; 2 b e g i n

3 p a r t i e I m a g i n a i r e := z . im ; 4end; { p a r t i e I m a g i n a i r e } 5

6 f u n c t i o n c o m p l e x e E n C h a i n e ( z : T C o m p l e x e ) : S t r i n g ; 7 v a r re , im : S t r i n g ;

8 b e g i n

9 str ( p a r t i e R e e l l e ( z ) :0: N B _ C H I F F R E S _ A P R E S _ V I R G U L E , re ) ; 10 str ( p a r t i e I m a g i n a i r e ( z ) :0: N B _ C H I F F R E S _ A P R E S _ V I R G U L E , im ) ; 11 c o m p l e x e E n C h a i n e := re + ’ + ’ + im + ’ i ’

12end; { c o m p l e x e E n C h a i n e } 13

14end.

(8)

as Utilisation d’une unit´ e pascal 1 / 4

On inclut une unit´ e dans un programme (ou dans une autre unit´ e) ` a l’aide de l’instruction uses

On peut alors utiliser les types, constantes et sous-programmes propos´ es dans l’interface de l’unit´ e

Lorsqu’il y a ambigu¨ıt´ e au niveau des identifiants, on doit pr´ efixer le type, la constante ou le sous-programme du nom de l’unit´ e suivi d’un .

Exemple

program e x e m p l e C o m p l e x e ; u s e s C o m p l e x e ;

v a r z1 : T C o m p l e x e ; b e g i n

z1 := C o m p l e x e . c o m p l e x e (1 ,2) ; w r i t e l n( c o m p l e x e E n C h a i n e ( z1 ) ) end.

(9)

Utilisation d’une unit´ e pascal 2 / 4

Remarques

Une unit´ e peut inclure une autre unit´ e dans la partie interface ou la partie implementation

L’inclusion

circulaire

d’unit´ es au niveau des interfaces est interdite

C’est possible si au moins une inclusion est au niveau de la partie implementation

Inclusion circulaire interdite

U n i t U n i t A ; i n t e r f a c e U s e s U n i t B ; i m p l e m e n t a t i o n end.

U n i t U n i t B i n t e r f a c e U s e s U n i t A ; i m p l e m e n t a t i o n end.

(10)

as Utilisation d’une unit´ e pascal 3 / 4

Inclusion circulaire autoris´ ee

U n i t U n i t A ; i n t e r f a c e U s e s U n i t B ; i m p l e m e n t a t i o n end.

U n i t U n i t B i n t e r f a c e i m p l e m e n t a t i o n U s e s U n i t A ; end.

(11)

Utilisation d’une unit´ e pascal 4 / 4

Compilation

Pour utiliser une unit´ e il faut qu’elle soit compil´ ee

On compile une unit´ e comme un programme Pascal (utilisation de fpc)

Au lieu d’obtenir un ex´ ecutable on obtient un fichier avec l’extension .ppu

Lorsque l’on compile une unit´ e ou un programme qui utilise une

unit´ e dont la date de compilation (.ppu) est plus ancienne que la

date de modification du code source (.pas), alors cette derni` ere

unit´ e est automatiquement recompil´ ee

(12)

as Tests unitaires 1 / 9

Les tests unitaires

Dans le cycle en V, ` a une unit´ e de compilation doit correspondre un test unitaire

Certaines m´ ethodologies de d´ eveloppement obligent ` a ´ ecrire les tests unitaires avant les unit´ es de compilation. . .

Les tests unitaires doivent tester le bon fonctionnement des

fonctions, proc´ edures et types propos´ es par les unit´ es de compilation Par exemple, on doit avoir :

partieReelle(complexe(a,b)) =a partieImaginaire(complexe(a,b)) =b complexeEnChaine(complexe(0,0)) =⁰0⁰ . . .

Il existe des frameworks facilitant le d´ eveloppement de tests unitaires

JUnit (Java), CUnit (C), AUnit (Ada), PhpUnit( PHP), DUnit

(Delphi), . . .

(13)

Tests unitaires 2 / 9

Les tests unitaires en Pascal

Une unit´ e pascal est une unit´ e de compilation

Il n’existe pas de framework de tests unitaires pour le freepascal non objet (sinon fpcunit)

On peut tr` es bien d´ evelopper des tests unitaires

` a la main

dont la structure ressemble aux tests unitaires propos´ es par ces

frameworks :

D´ evelopper une ou plusieurs proc´ edures (dont le nom est pr´ efix´ e par test) de tests unitaires par fonction ou proc´ edure ` a tester

Chaque proc´ edure teste la fonction ou proc´ edure et affiche “OK”

lorsque le test est valid´ e, “KO” sinon

Le programme principal appelle toutes les proc´ edures de test

(14)

as Tests unitaires 3 / 9

Tests unitaires de l’unit´ e complexe Que faut-il v´ erifier ?

partieReelle(complexe (1, 2)) = 1 partieImaginaire(complexe (1, 2)) = 2

complexeEnChaine(complexe(1, 2)) =

⁰

1.00 + 2.00i

⁰

(cas g´ en´ eral) complexeEnChaine(complexe(0, 0)) =

⁰

0

⁰

complexeEnChaine(complexe(1, 0)) =

⁰

1.00

⁰

complexeEnChaine(complexe(−1, 0)) =

⁰

−1.00

⁰

complexeEnChaine(complexe(0, 1)) =

⁰

1.00i

⁰

complexeEnChaine(complexe(0, −1)) =

⁰

−1.00i

⁰

(15)

Tests unitaires 4 / 9

Test unitaire : testcomplexe.pp

1program t e s t C o m p l e x e ; 2

3u s e s C o m p l e x e ; 4

5 p r o c e d u r e t e s t P a r t i e R e e l () ; 6 b e g i n

7 w r i t e( ’ p a r t i e R e e l l e : ’ ) ;

8 i f C o m p l e x e . p a r t i e R e e l l e ( C o m p l e x e . c o m p l e x e (1 ,2) ) =1 t h e n 9 w r i t e l n( ’ OK ’ )

10 e l s e

11 w r i t e l n( ’ KO ’ ) 12end; { t e s t P a r t i e R e e l } 13

14 p r o c e d u r e t e s t P a r t i e I m a g i n a i r e () ; 15 b e g i n

16 w r i t e( ’ p a r t i e I m a g i n a i r e : ’ ) ;

17 i f C o m p l e x e . p a r t i e I m a g i n a i r e ( C o m p l e x e . c o m p l e x e (1 ,2) ) =2 t h e n 18 w r i t e l n( ’ OK ’ )

19 e l s e

(16)

as Tests unitaires 5 / 9

Test unitaire : testcomplexe.pp

1 p r o c e d u r e t e s t C o m p l e x e E n C h a i n e C a s G e n e r a l () ; 2 b e g i n

3 w r i t e( ’ c o m p l e x e E n C h a i n e ( cas g e n e r a l ) : ’ ) ;

4 i f C o m p l e x e . c o m p l e x e E n C h a i n e ( C o m p l e x e . c o m p l e x e (1 ,2) ) = ’ 1 . 0 0 + 2 . 0 0 i ’ t h e n

5 w r i t e l n( ’ OK ’ )

6 e l s e

7 w r i t e l n( ’ KO ’ )

8end; { t e s t C o m p l e x e E n C h a i n e C a s G e n e r a l } 9

10 p r o c e d u r e t e s t C o m p l e x e E n C h a i n e C a s Z e r o () ; 11 b e g i n

12 w r i t e( ’ c o m p l e x e E n C h a i n e ( cas z e r o ) : ’ ) ;

13 i f C o m p l e x e . c o m p l e x e E n C h a i n e ( C o m p l e x e . c o m p l e x e (0 ,0) ) = ’ 0 ’ t h e n 14 w r i t e l n( ’ OK ’ )

15 e l s e

16 w r i t e l n( ’ KO ’ )

17end; { t e s t C o m p l e x e E n C h a i n e C a s Z e r o }

(17)

Tests unitaires 6 / 9

Test unitaire : testcomplexe.pp

1 p r o c e d u r e t e s t C o m p l e x e E n C h a i n e C a s R e e l P o s i t i f () ; 2 b e g i n

3 w r i t e( ’ c o m p l e x e E n C h a i n e ( cas r e e l ) : ’ ) ;

4 i f C o m p l e x e . c o m p l e x e E n C h a i n e ( C o m p l e x e . c o m p l e x e (1 ,0) ) = ’ 1 . 0 0 ’ t h e n

5 w r i t e l n( ’ OK ’ )

6 e l s e

7 w r i t e l n( ’ KO ’ )

8end; { t e s t C o m p l e x e E n C h a i n e C a s R e e l P o s i t i f } 9

10 p r o c e d u r e t e s t C o m p l e x e E n C h a i n e C a s R e e l N e g a t i f () ; 11 b e g i n

12 w r i t e( ’ c o m p l e x e E n C h a i n e ( cas r e e l n e g a t i f ) : ’ ) ;

13 i f C o m p l e x e . c o m p l e x e E n C h a i n e ( C o m p l e x e . c o m p l e x e ( -1 ,0) ) = ’ -1.00 ’ t h e n

14 w r i t e l n( ’ OK ’ )

15 e l s e

16 w r i t e l n( ’ KO ’ )

(18)

as Tests unitaires 7 / 9

Test unitaire : testcomplexe.pp

1 p r o c e d u r e t e s t C o m p l e x e E n C h a i n e C a s I m a g i n a i r e P o s i t i f () ; 2 b e g i n

3 w r i t e( ’ c o m p l e x e E n C h a i n e ( cas i m a g i n a i r e p o s i t i f ) : ’ ) ; 4 i f C o m p l e x e . c o m p l e x e E n C h a i n e ( C o m p l e x e . c o m p l e x e (0 ,1) ) = ’ 1 . 0 0 i ’

t h e n

5 w r i t e l n( ’ OK ’ )

6 e l s e

7 w r i t e l n( ’ KO ’ )

8end; { t e s t C o m p l e x e E n C h a i n e C a s I m a g i n a i r e P o s i t i f } 9

10 p r o c e d u r e t e s t C o m p l e x e E n C h a i n e C a s I m a g i n a i r e N e g a t i f () ; 11 b e g i n

12 w r i t e( ’ c o m p l e x e E n C h a i n e ( cas i m a g i n a i r e n e g a t i f ) : ’ ) ; 13 i f C o m p l e x e . c o m p l e x e E n C h a i n e ( C o m p l e x e . c o m p l e x e (0 , -1) ) = ’ -1.00 i ’

t h e n

14 w r i t e l n( ’ OK ’ )

15 e l s e

16 w r i t e l n( ’ KO ’ )

17end; { t e s t C o m p l e x e E n C h a i n e C a s I m a g i n a i r e N e g a t i f }

(19)

Tests unitaires 8 / 9

Test unitaire : testcomplexe.pp

1 b e g i n

2 w r i t e l n( ’ T e s t s u n i t a i r e s de l ’ ’ u n i t e c o m p l e x e : ’ ) ; 3 t e s t P a r t i e R e e l () ;

4 t e s t P a r t i e I m a g i n a i r e () ;

5 t e s t C o m p l e x e E n C h a i n e C a s G e n e r a l () ; 6 t e s t C o m p l e x e E n C h a i n e C a s Z e r o () ;

7 t e s t C o m p l e x e E n C h a i n e C a s R e e l P o s i t i f () ; 8 t e s t C o m p l e x e E n C h a i n e C a s R e e l N e g a t i f () ; 9 t e s t C o m p l e x e E n C h a i n e C a s I m a g i n a i r e P o s i t i f () ; 10 t e s t C o m p l e x e E n C h a i n e C a s I m a g i n a i r e N e g a t i f () 11end.

(20)

as Tests unitaires 9 / 9

Ex´ ecution du test

$ ./testComplexe

Tests unitaires de l’unite complexe : partieReelle : OK

partieImaginaire : OK

complexeEnChaine (cas general) : OK complexeEnChaine (cas zero) : KO complexeEnChaine (cas reel) : KO

complexeEnChaine (cas reel negatif) : KO

complexeEnChaine (cas imaginaire positif) : KO complexeEnChaine (cas imaginaire negatif) : KO

Exercice

Finir le d´ eveloppement de l’unit´ e complexe pour que tous les tests

passent

(21)

La documentation 1 / 3

Lorsque le nombre d’unit´ es augmente et que le nombre de sous-programmes par unit´ e est important, il est indispensale de fournir une documentation

L’insertion de la documentation dans le code permet de s’assurer que cette documentation est ` a jour

Des outils de documentation peuvent alors extraire certaines informations pour g´ en´ erer automatiquement la documentation

Ces informations doivent etre positionn´ ees dans le commentaire du code

Ces informations doivent suivrent certaines r` egles pour pouvoir ˆ etre interpr´ et´ ees par l’outil

Quelques outils :

Javadoc pour le Java, Phpdoc pour le Php, pasdoc pour le pascal, etc.

Doxygen pour le C++, C, Java, Objective-C, Python, IDL, Fortran,

(22)

as La documentation 2 / 3

Principe

Logiciel de Documentation Code source

Paramètres Documentation

(HTML, LaTeX,manpages, etc.)

(23)

La documentation 3 / 3

pasdoc

$pasdoc --help [...]

Usage: pasdoc [options] [files]

Valid options are:

-?, --help Show this help

--version Show pasdoc version (and related info)

-v, --verbosity Set log verbosity (0-6) [2]

-D, --define Define conditional

-R, --description Read description from this file

-d, --conditionals Read conditionals from this file

-I, --include Includes search path

-S, --source Read source filenames from file

--html-help-contents Read Contents for HtmlHelp from file

-F, --footer Include file as footer for HTML output

-H, --header Include file as header for HTML output

-N, --name Name for documentation

-T, --title Documentation title

-O, --format Output format: html, simplexml, latex, latex2rtf or

htmlhelp

-E, --output Output path

-X, --exclude-generator Exclude generator information

-L, --language Output language. Valid languages are:

[...]

fr: French (iso-8859-15) fr.utf8: French (UTF-8)

(24)

as Rappels

Crit` eres d’un bon programme pour la premi` ere version du puissance 4

lisible 7 3

fiable 7 3

maintenable 3

r´ eutilisable 7

portable 7

correct (preuve) 7

efficace (complexit´ e) 3

faire face ` a des contraintes ”´ economiques” 7

(25)

Unit´ es

Diagramme d’unit´ es (s’inspire des Diagrammes de classes d’UML)

Basic

+min() +max()

plateau

+autreJoueur() +vider() +contenuCase() +hauteurColonne() +jouer() +peutJouer()

+plateauTotalementRempli()

puissance4

+faireUnePartie()

+nombrePionsAlignesVerticalement() +nombrePionsAlignesHorizontalement()

+nombrePionsAlignesDiagonalementGaucheDroite() +nombrePionsAlignesDiagonalementDroiteGauche() +coupGagnant()

Puissance4Txt

(26)

as Les tests unitaires 1 / 6

Il faut faire des tests unitaires pour : l’unit´ e basic

l’unit´ e plateau l’unit´ e puissance4 Exercice

Faire les test unitaires de l’unit´ e plateau

(27)

Les tests unitaires 2 / 6

testBasic

1{ T e s t s u n i t a i r e s de l ’ u n i t ´e b a s i c } 2program t e s t B a s i c ;

3

4u s e s b a s i c ; 5

6p r o c e d u r e t e s t M i n P o s i t i f 1 () ; 7b e g i n

8 w r i t e( ’ min (1 ,2) =1 : ’ ) ; 9 i f min (1 ,2) =1 t h e n 10 w r i t e l n( ’ OK ’ ) 11 e l s e

12 w r i t e l n( ’ KO ’ ) 13end; { t e s t M i n P o s i t i f 1 } 14

15p r o c e d u r e t e s t M i n P o s i t i f 2 () ; 16b e g i n

17 w r i t e( ’ min (2 ,1) =1 : ’ ) ; 18 i f min (2 ,1) =1 t h e n 19 w r i t e l n( ’ OK ’ ) 20 e l s e

21 w r i t e l n( ’ KO ’ )

. . .

69p r o c e d u r e t e s t M a x A v e c U n N e g a t i f () ; 70b e g i n

71 w r i t e( ’ max ( -2 ,2) =2 : ’ ) ; 72 i f max ( -2 ,2) =2 t h e n 73 w r i t e l n( ’ OK ’ ) 74 e l s e

75 w r i t e l n( ’ KO ’ )

76end; { t e s t M a x A v e c U n N e g a t i f } 77

78b e g i n

79 w r i t e l n( ’ T e s t s u n i t a i r e s de l ’ ’ u n i t e b a s i c : ’ ) ;

80 t e s t M i n P o s i t i f 1 () ; 81 t e s t M i n P o s i t i f 2 () ; 82 t e s t M i n A v e c U n N u l () ; 83 t e s t M i n A v e c U n N e g a t i f () ; 84 t e s t M a x P o s i t i f 1 () ; 85 t e s t M a x P o s i t i f 2 () ; 86 t e s t M a x A v e c U n N u l () ; 87 t e s t M a x A v e c U n N e g a t i f () 88end.

(28)

as Les tests unitaires 3 / 6

ex´ ecution de testBasic

$ ./testBasic

Tests unitaires de l’unite basic : min(1,2)=1 : OK

min(2,1)=1 : OK

min(2,0)=0 : OK

min(-2,2)=-2 : OK

max(1,2)=2 : OK

max(2,1)=2 : OK

max(2,0)=2 : OK

max(-2,2)=2 : OK

(29)

as Les tests unitaires 4 / 6

testPuissance4

1{ T e s t s u n i t a i r e s de l ’ u n i t ´e p u i s s a n c e 4 } 2program t e s t P u i s s a n c e 4 ;

3

4u s e s plateau , p u i s s a n c e 4 ; 5

6

7 f u n c t i o n u n P l a t e a u () : T P l a t e a u ; 8b e g i n

9 v i d e r ( u n P l a t e a u ) ;

10 j o u e r ( u n P l a t e a u ,4 , p i o n J a u n e ) ; 11 j o u e r ( u n P l a t e a u ,4 , p i o n J a u n e ) ; 12 j o u e r ( u n P l a t e a u ,4 , p i o n J a u n e ) ; 13 j o u e r ( u n P l a t e a u ,3 , p i o n J a u n e ) ; 14 j o u e r ( u n P l a t e a u ,5 , p i o n J a u n e ) ; 15 j o u e r ( u n P l a t e a u ,6 , p i o n J a u n e ) ; 16 j o u e r ( u n P l a t e a u ,5 , p i o n J a u n e ) ; 17end;

18

19p r o c e d u r e t e s t N o m b r e P i o n s A l i g n e s H o r i z o n t a l e () ; 20b e g i n

21 w r i t e( ’ n o m b r e P i o n s A l i g n e s H o r i z o n t a l e m e n t ’ ) ;

22 i f n o m b r e P i o n s A l i g n e s H o r i z o n t a l e m e n t ( u n P l a t e a u () ,4 ,1) =4 t h e n 23 w r i t e l n( ’ OK ’ )

24 e l s e

25 w r i t e l n( ’ KO ’ ) 26end;

. . .

69p r o c e d u r e t e s t N o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e G a u c h e () ; 70b e g i n

71 w r i t e( ’ n o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e A G a u c h e ’ ) ;

72 i f n o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e A G a u c h e ( u n P l a t e a u () ,5 ,2) =3 t h e n 73 w r i t e l n( ’ OK ’ )

74 e l s e

75 w r i t e l n( ’ KO ’ ) 76end;

77 78b e g i n

79 w r i t e l n( ’ T e s t s u n i t a i r e s de l ’ ’ u n i t e p u i s s a n c e 4 : ’ ) ;

Modularit´e etc. v2.1 29 / 36

(30)

as Les tests unitaires 5 / 6

testPuissance4

69p r o c e d u r e t e s t N o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e G a u c h e () ; 70b e g i n

71 w r i t e( ’ n o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e A G a u c h e ’ ) ;

72 i f n o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e A G a u c h e ( u n P l a t e a u () ,5 ,2) =3 t h e n 73 w r i t e l n( ’ OK ’ )

74 e l s e

75 w r i t e l n( ’ KO ’ ) 76end;

77 78b e g i n

79 w r i t e l n( ’ T e s t s u n i t a i r e s de l ’ ’ u n i t e p u i s s a n c e 4 : ’ ) ; 80 t e s t N o m b r e P i o n s A l i g n e s H o r i z o n t a l e () ;

81 t e s t N o m b r e P i o n s A l i g n e s V e r t i c a l e () ;

82 t e s t N o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t G a u c h e D r o i t e () ; 83 t e s t N o m b r e P i o n s A l i g n e s D i a g o n a l e m e n t D r o i t e G a u c h e () ; 84end.

(31)

Les tests unitaires 6 / 6

ex´ ecution de testPuissance4

$ ./testPuissance4

Tests unitaires de l’unite puissance4 : nombrePionsAlignesHorizontalement OK nombrePionsAlignesVerticalement OK

nombrePionsAlignesDiagonalementGaucheADroite OK

nombrePionsAlignesDiagonalementDroiteAGauche OK

(32)

as La documentation 1 / 2

Un exemple : plateau

1{ U n i t ´e p e r m e t t a n t d ’ u t i l i s e r un p l a t e a u de p u i s s a n c e 4 2 @ a u t h o r N . D e l e s t r e

3}

4u n i t p l a t e a u ;

...

23{ F o n c t i o n p e r m e t t a n t d ’ o b t e n i r la c o u l e u r du p i o n a d v e r s e 24 @ p a r a m ( j o u e u r un p i o n )

25 @ r e t u r n s ( la c o u l e u r a d v e r s e ) 26}

27 f u n c t i o n a u t r e J o u e u r ( j o u e u r : T P i o n ) : T P i o n ;

28{ P r o c ´e d u r e p e r m e t t a n t de v i d e r un p l a t e u r de p u i s s a n c e 4 29 @ p a r a m ( l e P l a t e a u `a v i d e r )

30}

31p r o c e d u r e v i d e r (v a r l e P l a t e a u : T P l a t e a u ) ;

32{ F o n c t i o n p e r m e t t a n t d ’ o b t e n i r le c o n t e n u d ’ u n e c a s e d ’ un p l a t e a u de p u i s s a n c e 4 33 @ p a r a m ( l e P l a t e a u le p l a t e a u )

34 @ p a r a m ( c o l o n n e la c o l o n n e ) 35 @ p a r a m ( l i g n e la l i g n e )

36 @ r e t u r n s ( le c o n t e n u de la c a s e ( vide , p i o R o u g e ou p i o n J a u n e ) ) 37}

38 f u n c t i o n c o n t e n u C a s e ( l e P l a t e a u : T P l a t e a u ; c o l o n n e : T C o l o n n e ; l i g n e : T C o l o n n e ) : T C o n t e n u ;

(33)

La documentation 2 / 2

pasdoc

pasdoc --output doc/html --language fr --format HTML src/*.pas

(34)

as Compilation

Organisation Puissance4

compile.sh bin

src doc

html latex tests

compile.sh

fpc src / b a s i c . pas fpc src / p l a t e a u . pas fpc src / p u i s s a n c e 4 . pas fpc - o b i n / p u i s s a n c e 4 T x t src /

p u i s s a n c e 4 T x t . pas

fpc - o t e s t s / t e s t B a s i c src / t e s t B a s i c . pas

fpc - o t e s t s / t e s t P l a t e a u src / t e s t P l a t e a u . pas

fpc - o t e s t s / t e s t P u i s s a n c e 4 src / t e s t P u i s s a n c e 4 . pas

p a s d o c - - o u t p u t doc / h t m l - - l a n g u a g e fr - - f o r m a t H T M L src /*. pas

p a s d o c - - o u t p u t doc / l a t e x - - l a n g u a g e fr - - f o r m a t l a t e x src /*. pas

(35)

Qualit´ e du programme

Crit` eres d’un bon programme

avant apr` es

lisible 7 3 3

fiable 7 3 3

maintenable 3 3

r´ eutilisable 7 3

portable 7 7

correct (preuve) 7 7

efficace (complexit´ e) 3 3

faire face ` a des contraintes ”´ economiques” 7 3

(36)

as Conclusion

Les unit´ es Pascal permettent de faire du code r´ eellement r´ eutilisable Les tests unitaires permettent de s’assurer qu’une unit´ e fonctionnne correctement