Programmazione 2

JUNIT: TEST E DEBUG

Un software non funzionante presenta un malfunzionamento (il programma dà risultati scorretti) e un difetto (errore nel codice, alla base del malfunzionamento). Queste imperfezioni sono sempre relative ad una specifica che viene violata: i difetti a compile-time sono dovuti ad una scorrettezza nel linguaggio; quelli a run-time presentano una specifica del programma violata. Di conseguenza, si va ad effettuare testing per rilevare malfunzionamenti nel programma e debugging per evidenziare errori semantici.

TESTING

Non potendo effettuare test per tutti i possibili input, si distinguono:

• Casi normali: almeno un test per ogni dato valido;
• Casi anomali: almeno un test per una situazione errata o anomala che deve essere gestita dal programma;
• Casi di frontiera: almeno un test per i casi al confine tra comportamenti diversi.

Implementare ogni prova da effettuare nel main, però, è poco flessibile ed inefficace. Per questo si utilizza il framework JUnit.

JUnit è un framework che fornisce un ambiente di supporto all'esecuzione di test per Java. È integrato come plug-in in Eclipse.

In JUnit si testa per unità, le quali sono fondamentalmente i metodi del programma, inserendo dati come parametri o input e verificando se l'output coincide con il risultato atteso o meno.

Per eseguire un file in JUnit si parte da una classe contenente le funzioni implementate nel programma e si clicca, con il tasto destro, nel Package Explorer sulla sinistra, sul nome del progetto, andando poi su New > JUnit Test Case. Si passa poi a rinominare il file, facendo in modo che il nome assegnato rimandi alla funzione che si va a testare, e si seleziona New JUnit 4 test.

Verrà quindi creata una classe, nella quale si esegue il vero e proprio test, nella quale compare la dicitura: import static org.junit.Assert.*;

Qua dentro si andrà poi a creare un'istanza della classe con la funzione che si vuole testare e si effettueranno i dovuti test.

controlli. Ciò che si va effettivamente a testare è l'output, attraverso la funzione nella quale si passano come parametri il valore atteso e quello che assertEquals(), la funzione che si sta testando restituisce in output. Si clicca poi su Run, e, se i valori inseriti in coincidono, a sinistra assertEquals() compare una barra verde. Se invece discordano, la barra sarà di colore rosso. Se si vogliono invece testare tutte le funzioni della classe nello stesso momento (dopo aver creato le opportune classi in JUnit), evidenziando quali funzioni dannoproblemi, si clicca, sempre in corrispondenza del package, andando poi su Other > Java > JUnit > JUnit Test Suite. Nella finestra che si apre, si rinomina, poi si va su Package e si seleziona il packagedesiderato, insieme a tutte le classi JUnit che si vogliono testare. Verrà quindi creata una classe analoga a quella dei test per singola unità. Cliccando su Run, si evidenzieranno le funzioni che presentano

imperfezioni. Non esiste però solo la funzione per verificare il funzionamento assertEquals() di un metodo. Si può infatti fare riferimento ad un'intera libreria, la JUnit assertion library, che viene importata automaticamente mediante l'istruzione: ```html import org.junit.Assert; ``` Metodi Descrizione Afferma l'uguaglianza di due valori booleani. ```html static void assertEquals(boolean expected, boolean actual) ``` Afferma l'uguaglianza di due valori interi. ```html static void assertEquals(int expected, int actual) ``` Afferma l'uguaglianza di due stringhe. ```html static void assertEquals(String expected, String actual) ``` Afferma la falsità di una condizione. ```html static void assertFalse(boolean condition) ``` Afferma la veridicità di una condizione. ```html static void assertTrue(boolean condition) ``` Afferma che un oggetto è nullo. ```html static void assertNull(Object object) ``` Fallisce il test senza messaggi. ```html static void fail() ``` DEBUGGING Il debugging è il meccanismo che permette di localizzare i difetti che

causanomalfunzionamenti.Per effettuare il debug si parte a considerare un caso di test che evidenziamalfunzionamenti. Quindi si fa partire il programma fermando l'esecuzione in puntiintermedi, visionando i valori delle variabili in punti intermedi e cercando di capirein quale punto il programma presenta errori.

Si procede quindi inserendo breakpoint nei punti intermedi più significativi efermando l'esecuzione ad ogni breakpoint, esaminando lo stato del programma(corretto o scorretto).Quando si trova uno stato scorretto si interrompe l'esecuzione e si aggiungonoulteriori breakpoint tra quello corrispondente allo stato scorretto ed il breakpointprecedente. Nel caso le istruzioni siano poche si può anche procedere all'esecuzionepasso passo (un comando alla volta).

Per impostare un breakpoint si effettua doppio clic sul bordo in prossimità della rigain cui lo si vuole impostare.

Si passa poi al debugging vero e proprio, cliccando su Run > Debug

(oppure DebugAs > JUnit Test).I pulsanti utili sono Resume (riprende l’esecuzione dopo un breakpoint e avanza finoal successivo), Step Over (esegue un passo singolo e se l’istruzione eseguita è unachiamata di un metodo esegue fino alla prima istruzione successiva alla chiamata)e Step Into (esegue un passo singolo e se l’istruzione eseguita è una chiamata di unmetodo esegue fino alla prima istruzione del metodo chiamato).

JAVA COLLECTION FRAMEWORK

Una collezione (container) contiene più oggetti (elementi).

Il Java Collection Framework è l’insieme di interfacce e di classi perl’implementazione di collezioni. È costituito dai seguenti elementi:

• Interfacce che definiscono le operazioni di una generica collezione di oggetti;
• Classi concrete che implementano le interfacce utilizzando diversi tipi distrutture dati;
• Algoritmi di ricerca e di ordinamento utilizzati nelle classi concrete.

INTERFACCIA COLLECTION <

L'interfaccia ha la seguente sintassi: ObjectCollection Collection c1; è ottimizzata per operazioni di inserimento, modifica e cancellazione di elementi all'interno di un insieme di oggetti.

I metodi sono:

• Aggiunge alla collezione add([tipo_oggetto] elem)
• Svuota la collezione clear()
• Ritorna se l'oggetto appartiene alla collezione contains (Object o)
• Rimuove l'elemento dalla collezione remove (Object o)
• Ritorna il numero di elementi size()
• Ritorna un array con gli elementi della collezione toArray()

L'interfaccia Set extends Collection, è una collezione che non ammette duplicati (quest'ultima condizione è verificata tramite il metodo equals()).

Ha la seguente sintassi: ObjectSet s1; è quindi una sottoclasse di Collection, ma non la estende in termini di metodi, ma presenta diversa implementazione per alcuni di essi, ad esempio per il metodo add(E e), che aggiunge

alla collezione se non già presente. INTERFACCIA LIST EXTENDS COLLECTION L'interfaccia List è una collezione che presenta elementi ordinati la cui posizione è specificata da un intero e che accetta duplicati. Ha la seguente sintassi: ObjectList l1; È una sottoclasse di Collection che ne modifica la semantica di alcuni metodi: Collection: - aggiunge in fondo alla collezione se non già presente: add([tipo_oggetto] e); - rimuove il primo elemento della collezione: remove(Object o); A differenza di Set, List aggiunge metodi a Collection: METODI DESCRIZIONE - Aggiunge alla posizione index l'elemento e: add([int index, [tipo_oggetto] e); - Ritorna l'elemento alla posizione index: [tipo_oggetto] get (int index); - Ritorna la prima occorrenza di o oppure -1 se assente: int indexOf(Object o); - Ritorna l'ultima occorrenza di o oppure -1 se assente: int lastIndexOf(Object o); - Rimuove l'elemento alla posizione index: remove(int index); - Sostituisce l'elemento alla posizione index con e: set(int index, [tipo_oggetto] e);alla posizione set (int index, [tipo_oggetto] e) con index e ritorna la porzione della lista che va dalla posizione fromIndex alla posizione toIndex. INTERFACCIA MAP L'interfaccia Map permette di definire la struttura dati Mappa. Non estende Collection e non può nemmeno essere considerata una collezione, sebbene mantenga insiemi di coppie di elementi contraddistinti da una chiave e dal valore ad essa associato. La chiave identifica univocamente un elemento in una mappa. I principali metodi sono: - clear(): svuota la mappa; - containsKey(Object key): ritorna se esiste una chiave tale che key.equals(key); - containsValue(Object value): ritorna se esiste un valore tale che vv.equals(value); - get(Object key): ritorna l'elemento associato alla chiave oppure null; - keyset(): ritorna un Set con tutte le chiavi; - put(K key, V value): aggiunge un elemento con chiave key nel caso esista; - remove(Object key): rimuove l'elemento associato alla chiave key; - size(): ritorna il numero di elementi nella mappa; - values(): ritorna una Collection con tutti i valori della mappa.valore associato viene sostituito da value; ➢ se non esiste già un elemento associato, viene inserito il valore value; ➢ se esiste già un elemento associato, il valore viene sostituito da value; ➢ se non esiste un elemento associato, viene inserito il valore value; ➢ se esiste già un elemento associato, il valore non viene modificato; ➢ rimuove l'elemento associato alla chiave key; ➢ rimuove l'elemento associato alla chiave key solo se tale elemento corrisponde a value; ➢ ritorna il numero di coppie chiave-valore nella mappa; ➢ ritorna una collezione con i valori della mappa. IMPLEMENTAZIONI DELLE INTERFACCE Nelle classi concrete, comprese nel framework, è possibile utilizzare alcuni metodi che implementano le interfacce descritte sopra. ARRAYLIST In Java la lunghezza di un array, una volta che è stato dichiarato, non è più modificabile. Un modo per ovviare a questo problema è utilizzare un oggetto della classe ArrayList, presente nel package java.util. o ArrayList, è necessario importare la classe java.util.ArrayList. Una volta importata la classe, è possibile creare un oggetto ArrayList specificando il tipo di oggetti che verranno memorizzati al suo interno. Ad esempio, per creare un ArrayList di interi, si può utilizzare il seguente codice: ```html import java.util.ArrayList; public class Main { public static void main(String[] args) { ArrayList numeri = new ArrayList(); } } ``` Per aggiungere elementi all'ArrayList, si può utilizzare il metodo add(). Ad esempio, per aggiungere il numero 5 all'ArrayList "numeri", si può utilizzare il seguente codice: ```html numeri.add(5); ``` Per accedere agli elementi dell'ArrayList, si può utilizzare il metodo get(). Ad esempio, per ottenere il primo elemento dell'ArrayList "numeri", si può utilizzare il seguente codice: ```html int primoNumero = numeri.get(0); ``` Per rimuovere un elemento dall'ArrayList, si può utilizzare il metodo remove(). Ad esempio, per rimuovere il primo elemento dell'ArrayList "numeri", si può utilizzare il seguente codice: ```html numeri.remove(0); ``` È possibile ottenere la dimensione dell'ArrayList utilizzando il metodo size(). Ad esempio, per ottenere la dimensione dell'ArrayList "numeri", si può utilizzare il seguente codice: ```html int dimensione = numeri.size(); ``` È importante notare che l'ArrayList può memorizzare solo oggetti e non tipi di dato primitivi. Per utilizzare tipi di dato primitivi, è possibile utilizzare le classi wrapper corrispondenti. Ad esempio, per memorizzare valori interi, si può utilizzare la classe Integer: ```html ArrayList numeri = new ArrayList(); numeri.add(5); int primoNumero = numeri.get(0); ``` In conclusione, l'ArrayList è una struttura dati molto utile in Java che permette di memorizzare una sequenza di oggetti in modo dinamico.