SlideShare a Scribd company logo
LINGUAGGI DINAMICI
PARTE 3

APPLICAZIONI
AVANZATE

Linguaggi dinamici – A.A. 2009/2010
                                      1
Parte 3




                              Unit Testing
                                in Perl




Linguaggi dinamici – A.A. 2009/2010
                                             2
Introduzione
   Il Perl mette a disposizione tutta una serie di
     meccanismi per lo Unit Testing di moduli
         Moduli della gerarchia Test::*
         Test::Simple: test semplici, da eseguire su
           singoli statement
         Test::More: estensione di Test::More con più
           tipologie di controlli
         Test::Harness: creazione suite di test
   perldoc Test::Simple, perldoc Test::More,
     perldoc Test::Harness


Linguaggi dinamici – A.A. 2009/2010
                                                          3
Test semplici con Test::Simple
   Il modulo Test::Simple fornisce un supporto di
     base per lo Unit Testing in Perl
   Viene fornito il metodo di base per le
     asserzioni: ok()
         ok($expr, $test_name);
         Valuta $expr in contesto scalare, e stampa “ok”
           se tutto va bene, “not ok” se qualcosa va storto
         Se $name è una stringa non nulla, viene
           stampata insieme al risultato del test



Linguaggi dinamici – A.A. 2009/2010
                                                              4
Test semplici con Test::Simple
   Un test è un file richiedente Test::Simple ed
     invocante un certo numero di asserzioni ok()
   Il numero totale di asserzioni viene stampato
     all'inizio, nella forma 1..M (M=numero
     asserzioni)
   Il programma termina con un codice di uscita
     indicante quanti test sono stati sbagliati
         0: tutti i test sono andati a buon fine
         255: tutti i test sono falliti
         1-254: numero di test falliti


Linguaggi dinamici – A.A. 2009/2010
                                                     5
Test semplici con Test::Simple
   L'insieme dei test che si vuole eseguire è detto
     test plan
   E' possibile specificare il test plan in termini di
     numero di test da eseguire
         Parametro tests del modulo
         use Test::Simple tests = 1;
         Si riesce a capire se il test ha abortito
           prematuramente
   Il test plan deve essere specificato, pena un
     messaggio di errore


Linguaggi dinamici – A.A. 2009/2010
                                                           6
ESEMPI:
                                                  simple1.pl
        Test di moduli con Test::Simple           simple2.pl


   Si importa il modulo desiderato
   Si esegue una funzione del modulo
   Si confronta il risultato della funzione con un
     valore di riferimento
   Lo stesso discorso vale anche per gli oggetti!
   Con Test::Simple è possibile effettuare
     asserzioni solo su scalari semplici




Linguaggi dinamici – A.A. 2009/2010
                                                           7
Test più complessi con Test::More
   Il modulo Test::More introduce diverse
     estensioni funzionali a Test::Simple
         Test plan non dichiarabile esplicitamente
         Introduzione di asserzioni più complesse di ok()
         Supporto per i test condizionali
         Controllo del flusso di un test




Linguaggi dinamici – A.A. 2009/2010
                                                              8
ESEMPI:
                                                       more1.pl
     Test più complessi con Test::More                 more2.pl



   Analogamente a Test::Simple, è possibile
     predichiarare il numero di test eseguiti
     all'interno del file
   Diversamente da Test::Simple, tale
     dichiarazione non è più obbligatoria
         Funzione no_plan del modulo
         use Test::More qw( no_plan );
   E' anche possibile saltare l'intero test
         Parametro skip_all del modulo
         use Test::More skip_all = $skip_reason;


Linguaggi dinamici – A.A. 2009/2010
                                                              9
ESEMPI:
                                                        more3.pl
     Test più complessi con Test::More
   E' possibile calcolare dinamicamente il numero
     di test che saranno eseguiti!
   Funzione plan():
         associa al parametro tests il risultato di una
           espressione
         oppure associa al parametro skip_all il motivo
           della non esecuzione del test
   E' possibile differenziare il test fra diversi
     sistemi operativi, usando la variabile speciale
     $^O


Linguaggi dinamici – A.A. 2009/2010
                                                              10
ESEMPI:
                                                             more4.pl
     Test più complessi con Test::More
   Asserzione is(): è funzionalmente identica ad
     ok()
         Effettua il controllo con eq
         Stampa il motivo per cui l'asserzione fallisce
         Fortemente consigliata rispetto ad ok()
   Asserzione isnt(): negazione di is()
         Effettua il controllo con ne
         Stampa il motivo per cui l'asserzione fallisce
         Fortemente consigliata rispetto a ! ok()



Linguaggi dinamici – A.A. 2009/2010
                                                                   11
ESEMPI:
                                                           more5.pl
     Test più complessi con Test::More
   Asserzione like(): controlla se una variabile fa
     match con una espressione regolare
         like($got, qr/expected/, 'this is like that');
         Equivalente a ok( $got =~ /expected/, 'this is like
           that');
   L'uso di like() è preferito, per via del miglior
     output diagnostico
   Si noti l'operatore qr, che compila una
     espressione in una espressione regolare
         perldoc perlop
   Asserzione unlike(): negazione di like()
Linguaggi dinamici – A.A. 2009/2010
                                                                 12
Test più complessi con Test::More
   Asserzione cmp_ok(): confronto effettuato con
     una funzione specifica
         cmp_ok( $got, 'eq', $expected, 'this eq that' );
         cmp_ok( $got, '==', $expected, 'this == that' );




Linguaggi dinamici – A.A. 2009/2010
                                                              13
ESEMPI:
                                                          more6.pl
     Test più complessi con Test::More                    more8.pl



   Asserzione can_ok(): verifica se un modulo
     (oppure un'istanza di oggetto) hanno a
     disposizione il metodo specificato
         can_ok('Foo', qw(method_name));
         Equivalente a ok(Foo-can('method_name'));
   Asserzione isa_ok(): verifica se un oggetto è
     un'istanza di una classe specifica
         isa_ok( $obj, 'Some::Module' );
         Equivalente a ok(Foo-isa('Some::Module'));



Linguaggi dinamici – A.A. 2009/2010
                                                                14
ESEMPI:
                                                     more7.pl
     Test più complessi con Test::More
   Asserzione pass(): crea un test che passa
     sempre
         Equivalente a ok(1);
   Asserzione fail(): crea un test che fallisce
     sempre
         Equivalente a ok(0);




Linguaggi dinamici – A.A. 2009/2010
                                                           15
Test più complessi con Test::More
   Asserzione new_ok(): crea un oggetto di una
     data classe, lo assegna ad una variabile e
     verifica la corretta creazione
         my $obj = new_ok( $class );
         my $obj = new_ok( $class = @args );
         Equivalente a
             my $obj = $class-new(@args);


             isa_ok $obj, $class, $object_name;




Linguaggi dinamici – A.A. 2009/2010
                                                    16
Test più complessi con Test::More
   Asserzione use_ok(): verifica se è possibile
     caricare un dato modulo
         BEGIN { use_ok($module); }
         BEGIN { use_ok($module, @imports); }
   L'asserzione va inserita in un blocco BEGIN
         In tal modo, le funzioni esportate sono
           disponibili al test subito dopo la compilazione




Linguaggi dinamici – A.A. 2009/2010
                                                             17
ESEMPI:
            Esecuzione condizionale con                    more9.pl

                    Test::More
   E' possibile definire due blocchi di codice dal
     nome SKIP e TODO
   Blocco SKIP: dichiara una sequenza di test che
     devono essere ignorati
         Contiene una chiamata di funzione skip che
           specifica quanti test saltare, sotto quale
           condizione
   Blocco TODO: dichiara una sequenza di test
     che ci si aspetta fallisca
         Contiene una assegnazione del motivo di
           fallimento alla variabile stringa local TODO

Linguaggi dinamici – A.A. 2009/2010
                                                                 18
ESEMPI:
                                                    harness1.pl
           Suite di test con Test::Harness
   Il modulo Test::Harness fornisce uno
     strumento basilare per la creazione di suite di
     test
   Viene messo a disposizione il metodo runtests
     ()
         Accetta una lista di nomi di file
         Esegue i test relativi
         Interpreta lo stdout dei test
         Costruisce e presenta un report finale
   E' convenzione usare l'estensione .t con i file
     di test appartenenti a suite
Linguaggi dinamici – A.A. 2009/2010
                                                             19

More Related Content

PDF
Py a1 python-unit_testing
PPTX
Test double - un'introduzione (PHP)
PDF
Pe a3 perl-metaprogramming
PPT
7 Sottoprogrammi
PDF
Le funzioni in javascript
PPT
Java codestyle & tipstricks
PPTX
2011.02.19 Introducing F#
PDF
Pe t2 perl-caratteristiche
Py a1 python-unit_testing
Test double - un'introduzione (PHP)
Pe a3 perl-metaprogramming
7 Sottoprogrammi
Le funzioni in javascript
Java codestyle & tipstricks
2011.02.19 Introducing F#
Pe t2 perl-caratteristiche

Viewers also liked (20)

PDF
Pe t1 perl-intro
PDF
T2 architettura
PDF
T7 librerie
PPT
UE week 2
PDF
T3 esempio runtime
PDF
T5 memoria
PDF
T4 tipizzazione
PDF
T8 supporti
PDF
T1 introduzione
PDF
T6 codice
PDF
Pe t3 perl-moduli
PPT
Corso Python Django
PDF
Py a2 python-documentazione
PDF
Py a3 python-metaprogramming
PDF
Py t1 python-intro
PDF
Pe a2 perl-documentazione
PDF
Pe t4 perl-oggetti
PDF
Py a4 python-file
PDF
Py a6 python-database
PDF
9 - Architetture Software - SOA Cloud
Pe t1 perl-intro
T2 architettura
T7 librerie
UE week 2
T3 esempio runtime
T5 memoria
T4 tipizzazione
T8 supporti
T1 introduzione
T6 codice
Pe t3 perl-moduli
Corso Python Django
Py a2 python-documentazione
Py a3 python-metaprogramming
Py t1 python-intro
Pe a2 perl-documentazione
Pe t4 perl-oggetti
Py a4 python-file
Py a6 python-database
9 - Architetture Software - SOA Cloud
Ad

Similar to Pe a1 perl-unit_testing (20)

ODP
Unit testing 101
PDF
Presentazione della Tesi di Laurea Specialistica : STRUMENTI PER LA GENERAZIO...
PPT
Introduzione al Test Driven Development
PDF
Baby Steps TripServiceKata
PPTX
Unit Test di Gabriele Seroni
ODP
PDF
Java Unit Testing - JUnit (1)
PDF
Testing in javascript
PDF
Googletest, tdd e mock
PDF
Delphi & Dintorni Webinar - Diventa un mago del Testing
ODP
Consigli per iniziare tdd
PDF
Java Unit Testing - JUnit (2)
ODP
Presentazione Oz - Mozart
PDF
Corso Programmazione Java Base
PPTX
PDF
Java 8: le nuove-interfacce di Ezio Sperduto
PDF
Android Test Driven Development
PDF
Android Test Driven Development
PDF
Software Testing e TDD
Unit testing 101
Presentazione della Tesi di Laurea Specialistica : STRUMENTI PER LA GENERAZIO...
Introduzione al Test Driven Development
Baby Steps TripServiceKata
Unit Test di Gabriele Seroni
Java Unit Testing - JUnit (1)
Testing in javascript
Googletest, tdd e mock
Delphi & Dintorni Webinar - Diventa un mago del Testing
Consigli per iniziare tdd
Java Unit Testing - JUnit (2)
Presentazione Oz - Mozart
Corso Programmazione Java Base
Java 8: le nuove-interfacce di Ezio Sperduto
Android Test Driven Development
Android Test Driven Development
Software Testing e TDD
Ad

More from Majong DevJfu (20)

PDF
8 - Architetture Software - Architecture centric processes
PDF
7 - Architetture Software - Software product line
PDF
6 - Architetture Software - Model transformation
PDF
5 - Architetture Software - Metamodelling and the Model Driven Architecture
PDF
4 - Architetture Software - Architecture Portfolio
PDF
3 - Architetture Software - Architectural styles
PDF
2 - Architetture Software - Software architecture
PDF
1 - Architetture Software - Software as a product
PDF
10 - Architetture Software - More architectural styles
PDF
PDF
PDF
4 (uml basic)
POT
Tmd template-sand
PPT
26 standards
PPT
25 architectural adaptation
8 - Architetture Software - Architecture centric processes
7 - Architetture Software - Software product line
6 - Architetture Software - Model transformation
5 - Architetture Software - Metamodelling and the Model Driven Architecture
4 - Architetture Software - Architecture Portfolio
3 - Architetture Software - Architectural styles
2 - Architetture Software - Software architecture
1 - Architetture Software - Software as a product
10 - Architetture Software - More architectural styles
4 (uml basic)
Tmd template-sand
26 standards
25 architectural adaptation

Pe a1 perl-unit_testing

  • 2. Parte 3 Unit Testing in Perl Linguaggi dinamici – A.A. 2009/2010 2
  • 3. Introduzione Il Perl mette a disposizione tutta una serie di meccanismi per lo Unit Testing di moduli Moduli della gerarchia Test::* Test::Simple: test semplici, da eseguire su singoli statement Test::More: estensione di Test::More con più tipologie di controlli Test::Harness: creazione suite di test perldoc Test::Simple, perldoc Test::More, perldoc Test::Harness Linguaggi dinamici – A.A. 2009/2010 3
  • 4. Test semplici con Test::Simple Il modulo Test::Simple fornisce un supporto di base per lo Unit Testing in Perl Viene fornito il metodo di base per le asserzioni: ok() ok($expr, $test_name); Valuta $expr in contesto scalare, e stampa “ok” se tutto va bene, “not ok” se qualcosa va storto Se $name è una stringa non nulla, viene stampata insieme al risultato del test Linguaggi dinamici – A.A. 2009/2010 4
  • 5. Test semplici con Test::Simple Un test è un file richiedente Test::Simple ed invocante un certo numero di asserzioni ok() Il numero totale di asserzioni viene stampato all'inizio, nella forma 1..M (M=numero asserzioni) Il programma termina con un codice di uscita indicante quanti test sono stati sbagliati 0: tutti i test sono andati a buon fine 255: tutti i test sono falliti 1-254: numero di test falliti Linguaggi dinamici – A.A. 2009/2010 5
  • 6. Test semplici con Test::Simple L'insieme dei test che si vuole eseguire è detto test plan E' possibile specificare il test plan in termini di numero di test da eseguire Parametro tests del modulo use Test::Simple tests = 1; Si riesce a capire se il test ha abortito prematuramente Il test plan deve essere specificato, pena un messaggio di errore Linguaggi dinamici – A.A. 2009/2010 6
  • 7. ESEMPI: simple1.pl Test di moduli con Test::Simple simple2.pl Si importa il modulo desiderato Si esegue una funzione del modulo Si confronta il risultato della funzione con un valore di riferimento Lo stesso discorso vale anche per gli oggetti! Con Test::Simple è possibile effettuare asserzioni solo su scalari semplici Linguaggi dinamici – A.A. 2009/2010 7
  • 8. Test più complessi con Test::More Il modulo Test::More introduce diverse estensioni funzionali a Test::Simple Test plan non dichiarabile esplicitamente Introduzione di asserzioni più complesse di ok() Supporto per i test condizionali Controllo del flusso di un test Linguaggi dinamici – A.A. 2009/2010 8
  • 9. ESEMPI: more1.pl Test più complessi con Test::More more2.pl Analogamente a Test::Simple, è possibile predichiarare il numero di test eseguiti all'interno del file Diversamente da Test::Simple, tale dichiarazione non è più obbligatoria Funzione no_plan del modulo use Test::More qw( no_plan ); E' anche possibile saltare l'intero test Parametro skip_all del modulo use Test::More skip_all = $skip_reason; Linguaggi dinamici – A.A. 2009/2010 9
  • 10. ESEMPI: more3.pl Test più complessi con Test::More E' possibile calcolare dinamicamente il numero di test che saranno eseguiti! Funzione plan(): associa al parametro tests il risultato di una espressione oppure associa al parametro skip_all il motivo della non esecuzione del test E' possibile differenziare il test fra diversi sistemi operativi, usando la variabile speciale $^O Linguaggi dinamici – A.A. 2009/2010 10
  • 11. ESEMPI: more4.pl Test più complessi con Test::More Asserzione is(): è funzionalmente identica ad ok() Effettua il controllo con eq Stampa il motivo per cui l'asserzione fallisce Fortemente consigliata rispetto ad ok() Asserzione isnt(): negazione di is() Effettua il controllo con ne Stampa il motivo per cui l'asserzione fallisce Fortemente consigliata rispetto a ! ok() Linguaggi dinamici – A.A. 2009/2010 11
  • 12. ESEMPI: more5.pl Test più complessi con Test::More Asserzione like(): controlla se una variabile fa match con una espressione regolare like($got, qr/expected/, 'this is like that'); Equivalente a ok( $got =~ /expected/, 'this is like that'); L'uso di like() è preferito, per via del miglior output diagnostico Si noti l'operatore qr, che compila una espressione in una espressione regolare perldoc perlop Asserzione unlike(): negazione di like() Linguaggi dinamici – A.A. 2009/2010 12
  • 13. Test più complessi con Test::More Asserzione cmp_ok(): confronto effettuato con una funzione specifica cmp_ok( $got, 'eq', $expected, 'this eq that' ); cmp_ok( $got, '==', $expected, 'this == that' ); Linguaggi dinamici – A.A. 2009/2010 13
  • 14. ESEMPI: more6.pl Test più complessi con Test::More more8.pl Asserzione can_ok(): verifica se un modulo (oppure un'istanza di oggetto) hanno a disposizione il metodo specificato can_ok('Foo', qw(method_name)); Equivalente a ok(Foo-can('method_name')); Asserzione isa_ok(): verifica se un oggetto è un'istanza di una classe specifica isa_ok( $obj, 'Some::Module' ); Equivalente a ok(Foo-isa('Some::Module')); Linguaggi dinamici – A.A. 2009/2010 14
  • 15. ESEMPI: more7.pl Test più complessi con Test::More Asserzione pass(): crea un test che passa sempre Equivalente a ok(1); Asserzione fail(): crea un test che fallisce sempre Equivalente a ok(0); Linguaggi dinamici – A.A. 2009/2010 15
  • 16. Test più complessi con Test::More Asserzione new_ok(): crea un oggetto di una data classe, lo assegna ad una variabile e verifica la corretta creazione my $obj = new_ok( $class ); my $obj = new_ok( $class = @args ); Equivalente a my $obj = $class-new(@args); isa_ok $obj, $class, $object_name; Linguaggi dinamici – A.A. 2009/2010 16
  • 17. Test più complessi con Test::More Asserzione use_ok(): verifica se è possibile caricare un dato modulo BEGIN { use_ok($module); } BEGIN { use_ok($module, @imports); } L'asserzione va inserita in un blocco BEGIN In tal modo, le funzioni esportate sono disponibili al test subito dopo la compilazione Linguaggi dinamici – A.A. 2009/2010 17
  • 18. ESEMPI: Esecuzione condizionale con more9.pl Test::More E' possibile definire due blocchi di codice dal nome SKIP e TODO Blocco SKIP: dichiara una sequenza di test che devono essere ignorati Contiene una chiamata di funzione skip che specifica quanti test saltare, sotto quale condizione Blocco TODO: dichiara una sequenza di test che ci si aspetta fallisca Contiene una assegnazione del motivo di fallimento alla variabile stringa local TODO Linguaggi dinamici – A.A. 2009/2010 18
  • 19. ESEMPI: harness1.pl Suite di test con Test::Harness Il modulo Test::Harness fornisce uno strumento basilare per la creazione di suite di test Viene messo a disposizione il metodo runtests () Accetta una lista di nomi di file Esegue i test relativi Interpreta lo stdout dei test Costruisce e presenta un report finale E' convenzione usare l'estensione .t con i file di test appartenenti a suite Linguaggi dinamici – A.A. 2009/2010 19