Obiettivi:
Creare ed accedere a un pool di dati da un'applicazione di verifica di esempio utilizzando le funzioni
Verifica Eclipse e TPTP (Performance Tools Platform).
Tempo necessario
1 ora
Prima di iniziare l'esercitazione è necessario:
-
Installare Eclipse e TPTP (Test and Performance Tools).
- Conoscere le procedure di verifica JUnit. Per ulteriori informazioni sulla verifica JUnit, fare riferimento a
www.junit.org.
- Configurare ed eseguire l'Agent Controller che corrisponde alla versione di TPTP utilizzata. Per ulteriori informazioni fare riferimento alla sezione Getting started with the Agent Controller.
Descrizione
In questa esercitazione verrà creata una verifica ed un'applicazione chiamata
MyShoppingCart. Utilizzando TPTP (Test and Performance Tools Platform) di Eclipse, è possibile sviluppare
verifiche JUnit e creare pool di dati che forniscono dati all'ambiente di verifica.
Questa esercitazione illustra le seguenti procedure:
- Creazione di un'applicazione utente di esempio
- Impostazione di una suite di verifica TPTP
- Creazione di un pool di dati e inizializzazione dei dati di verifica
- Modifica dei casi di prova per fare riferimento a un pool di dati
In questa procedura viene sviluppata la classe MyShoppingCart. Nelle procedure successive, verrò utilizzato TPTP per sviluppare l'ambiente di verifica corrispondente.
- Creare un nuovo progetto Java Eclipse.
- Dal menu File, scegliere File > Nuovo > Progetto.... Viene visualizzata la finestra
Nuovo progetto.
- Nell'elenco delle procedure guidate, selezionare Progetto Java e scegliere Avanti.
Viene visualizzata la pagina Creazione progetto Java.
- Immettere datapoolExample come nome del progetto e scegliere Fine.
Il progetto datapoolExample viene visualizzato nella vista di selezione.
- Creare la classe MyShoppingCart.
- Nella vista Selezione, selezionare il progetto datapoolExample con il tasto destro del mouse e scegliere
Nuova > Classe. Viene visualizzata la finestra Nuova classe Java.
- Immettere MyShoppingCart nel campo Nome.
- Deselezionare l'opzione per la creazione del metodo principale public static void
main(String[] args).
- Scegliere Fine. Il file MyShoppingCart.java viene visualizzato nell'editor Java.
- Immettere quanto segue per l'origine di MyShoppingCart:
import java.util.*;
public class MyShoppingCart {
public Hashtable myFlowers;
public MyShoppingCart() {
myFlowers = new Hashtable();
myFlowers.put("Orchid", new Double(5.99));
myFlowers.put("Tulip", new Double(1.99));
myFlowers.put("White Poinsee", new Double(6.99));
myFlowers.put("White Rose", new Double(9.99));
myFlowers.put("Geraniums", new Double(4.99));
}
public double itemCost(String itemName, int itemQuantity)
{
Double price = (Double)myFlowers.get(itemName);
if (price != null) {
return price.doubleValue()*itemQuantity;
}
return -1;
}
}
- Salvare MyShoppingCart.java. Dal menu File scegliere File > Salva.
In questa procedura viene sviluppata una suite di verifica per la classe MyShoppingCart. Utilizzando TPTP, verrà sviluppata una verifica JUnit per il metodo itemCost.
- Aprire la prospettiva Verifica.
- Dal menu File, scegliere Finestra > Apri prospettiva > Altro.
- Selezionare Verifica e scegliere OK. Viene visualizzata la finestra Esplora verifica.
- Creare una nuova verifica TPTP JUnit.
- In Esplora verifica, selezionare il progetto datapoolExample con il tasto destro del mouse e scegliere
Nuovo > Elemento di verifica...
- Nella finestra Elemento di verifica, selezionare Verifica TPTP JUnit e scegliere Avanti. Viene visualizzata la finestra Nuovo caso di prova, in cui si richiede di aggiungere le librerie JUnit. Scegliere Sì per aggiungere le librerie JUnit.
- Nella pagina Codice di origine della nuova verifica JUnit, immettere shoppingCartTest_src
nel campo Nome. Nella sezione Selezionare come viene modificato il comportamento di verifica, scegliere
l'opzione di modifica Nell'editor di testo (la predefinita).
- Scegliere Fine. Viene visualizzato l'editor Verifica TPTP JUnit, contenente la suite di verifica
shoppingCartTest_src. La scheda Panoramica, contiene una descrizione della verifica, informazioni sull'origine e un elenco
di metodi di verifica. Attualmente non sono stati definiti metodi di verifica. Per questa esercitazione, l'editor di verifica
TPTP JUnit genererà stub di metodo in modo che l'opzione Implementa il comportamento di verifica come codice
nella sezione Informazioni sull'origine venga deselezionata. Per ulteriori informazioni, fare riferimento
alla sezione Editor suite di verifica JUnit.
- Aggiungere i metodi testItemCost e testShoppingCartConstructor.
- Nella scheda Metodi di verifica, scegliere Aggiungi. Viene visualizzato un nome predefinito per la verifica.
- Aggiungere il metodo testItemCost. Nel campo Nome, immettere testItemCost come nuovo nome per la
verifica. Nel campo Descrizione, immettere Verifica per il metodo MyShoppingCart.itemCost(String, int).
- Aggiungere il metodo testShoppingCartConstructor. Nella scheda Metodi di verifica, scegliere Aggiungi. Nel campo Nome, immettere testShoppingCartConstructor come nuovo nome per la
verifica. Nel campo Descrizione, immettere Verifica per il costruttore MyShoppingCart.
- Configurare il comportamento dell'esecuzione della verifica.
- Aggiungere un ciclo di esecuzione. Nella scheda Comportamento, scegliere Aggiungi...> Ciclo. Nel campo Nome, immettere Loop_MyShoppingCart. Nel campo Numero di iterazioni, immettere
1 (il valore predefinito).
- Aggiungere un richiamo a testShoppingCartConstructor. Selezionare
Loop_MyShoppingCart e scegliere Aggiungi ... > Richiamo. Viene visualizzata la finestra Richiamo verifica. Selezionare testShoppingCartConstructor e scegliere OK.
- Aggiungere un richiamo a testItemCost. Selezionare
Loop_MyShoppingCart e scegliere Aggiungi ... > Richiamo. Viene visualizzata la finestra Richiamo verifica. Selezionare testItemCost e scegliere OK.
- Salvare la suite di verifica. Dal menu File, scegliere File > Salva.
Nota: scegliendo Salva, l'editor Verifica TPTP JUnit creerà stub di metodo di verifica in
shoppingCartTest_src.java.
-
Immettere il codice per i metodi di verifica JUnit generati testShoppingCartConstructor e testItemCost.
- Aprire la prospettiva Java. Dal menu File scegliere Finestra > Apri prospettiva > Altro... > Java.
- Aprire shoppingCartTest_src.java. Nel pannello di selezione, aprire la cartella del progetto datapoolExample
e fare doppio clic su shoppingCartTest_src.java. Il contenuto di shoppingCartTest_src.java viene visualizzato
nell'editor Java, compreso il codice per impostare ed eseguire la suite di verifica
e i metodi di stub per testShoppingCartConstructor e testItemCost.
- Immettere il seguente codice per il metodo testShoppingCartConstructor.
public void testShoppingCartConstructor()
throws Exception
{
MyShoppingCart cart = new MyShoppingCart();
Double priceOrchid = (Double)cart.myFlowers.get("Orchid");
Double priceTulip = (Double)cart.myFlowers.get("Tulip");
assertTrue(priceOrchid.doubleValue() == 5.99);
assertTrue(priceTulip.doubleValue() == 1.99);
}
- Immettere il seguente codice per il metodo testItemCost.
public void testItemCost()
throws Exception
{
MyShoppingCart cart = new MyShoppingCart();
double priceForTwo = cart.itemCost("Orchid", 2);
assertTrue(priceForTwo == 11.98);
}
- Salvare shoppingCartTest_src.java. Dal menu File, scegliere File > Salva.
- Aprire la prospettiva Verifica e creare una distribuzione di verifica. Per un esempio, fare riferimento alla sezione Creazione di una
distribuzione di verifica.
-
Eseguire la verifica utilizzando la distribuzione personalizzata.
- In Esplora verifica, selezionare la suite di verifica shoppingCartTest_src con il tasto destro del mouse e
scegliere Esegui come > Esegui.... Viene visualizzata la finestra Esecuzione configurazione.
- Nel riquadro Configurazioni, selezionare Verifica quindi scegliere Nuovo.
- Nel riquadro a sinistra della finestra Esecuzione configurazione (Selezionare la verifica da eseguire),
espandere datapoolExample e scegliere la suite di verifica shoppingCartTest_src.
- Nel riquadro a destra della finestra Esecuzione configurazione, selezionare la distribuzione creata.
- Nella scheda Log di verifica, deselezionare l'opzione Utilizza impostazione predefinita e selezionare la
cartella del progetto datapoolExample.
- Scegliere Esegui per avviare la verifica.
- Fare doppio clic sul log di verifica shoppingCartTest_src, visualizzato nel pannello di selezione. Viene visualizzato il log di verifica shoppingCartTest_src. Selezionare la scheda Eventi per visualizzare
i dettagli della verifica. Dovrebbero essere visualizzati i seguenti eventi:
avvio della suite di verifica, avvio di Loop_MyShoppingCart, avvio della verifica, verdetto della verifica,
arresto della verifica, secondo avvia della verifica, secondo verdetto della verifica, secondo arresto della verifica,
arresto del ciclo, verdetto della suite di verifica e arresto della suite di verifica.

In questa procedura, verrà creato un semplice pool di dati per archiviare i dati della verifica. Utilizzando l'editor del pool di dati, verranno definiti gli elementi strutturali del pool di dati, incluse
le variabili (colonne), i record (righe) e le classi di equivalenza (gruppi di record correlati).
- Creare un file CSV (delimitato da virgole) che contiene i dati della verifica. Generalmente, è possibile esportare i dati da un'applicazione con fogli elettronici o da un database al formato
CSV. In questa esercitazione, tuttavia, i dati verranno immessi in un editor di testo.
- Immettere quanto segue in un editor di testo.
,ModelNumber::String,Description::String,Price::Double
flowers,F0001,Orchid,5.99
flowers,F0002,Tulip,1.99
flowers,F0003,White Poinsee,6.99
flowers,F0004,White Rose,9.99
flowers,F0005,Geraniums,4.99
- Salvare il file come flowerData.csv in un percorso temporaneo esterno.
- In Eclipse, aprire la prospettiva Verifica.
- Dal menu File, scegliere Finestra > Apri prospettiva > Altro.
- Selezionare Verifica e scegliere OK. Viene visualizzata la finestra Esplora verifica.
- Nel pannello di selezione, selezionare un progetto con il tasto destro del mouse e
scegliere Nuovo > Elemento di verifica....
Viene visualizzata la finestra Nuovo elemento di verifica.
- Nell'elenco delle procedure guidate, espandere la cartella
Risorse di verifica e selezionare Pool di dati.
- Fare clic su Avanti. Viene visualizzata la finestra
Nuovo pool di dati.
- Scegliere la cartella del progetto del pool di dati e il nome del pool di dati. Nell'elenco dei progetti esistenti, selezionare il progetto datapoolExample. Nel campo Nome, immettere shoppingCartDatapool. Scegliere Avanti
per continuare, quindi di nuovo Avanti per aprire la pagina di importazione per il file CSV.
- Importare il file CSV flowerData.csv.
- Nel campo File CSV, scegliere Sfoglia
e navigare al file flowerData.csv.
- Selezionare l'opzione La prima riga contiene i nomi di variabili e i
tipi suggeriti. La prima riga di flowerData.csv contiene intestazioni di colonna e tipi.
- Selezionare l'opzione La prima colonna contiene i nomi delle
classi di equivalenza. Le classi di equivalenza raggruppano i dati correlati. La prima colonna di flowerData.csv indica una singola classe di equivalenza chiamata flowers.
- Scegliere Fine. Se sono state specificate
dimensioni iniziali del pool di dati che potrebbero creare un conflitto con le dimensioni
del file CVS, viene visualizzato un messaggio. Scegliere Sì per utilizzare le dimensioni del file CSV. Scegliere No per utilizzare le dimensioni iniziali specificate (ed eventualmente troncare i dati del file
CSV).
Viene visualizzato l'editor del pool di dati, che mostra i dati contenuti nella classe di equivalenza
flowers.
Per informazioni dettagliate sulla creazione dei pool di dati, fare riferimento alla sezione
Creazione di un pool di dati.
In questa procedura verrà utilizzata l'API del pool di dati in sostituzione dei valori di verifica
codificati con riferimenti alle colonne del pool di dati.
Aggiunta delle librerie richieste dall'API del pool di dati
L'API del pool di dati richiede
diverse librerie TPTP e EMF (Eclipse Modeling Framework). In questa procedura, verranno aggiunte le librerie al percorso di generazione Java.
- Aprire la prospettiva Java. Dal menu File, scegliere Finestra >
Apri prospettiva > Java.
- Aprire le proprietà del progetto datapoolExample. Nella finestra Selezione o Esplora pacchetti, selezionare la cartella del progetto datapoolExample con
il tasto destro del mouse e scegliere Proprietà. Viene visualizzata la finestra Proprietà per datapoolExample.
- Aggiungere tptp-models.jar al percorso di generazione Java.
-
Nel riquadro a sinistra, selezionare Percorso di generazione Java.
- Nel riquadro a destra, selezionare la scheda Librerie e scegliere Aggiungi
variabile.... Viene visualizzata la finestra Nuova voce percorso classi di variabili.
- Selezionare la variabile ECLIPSE_HOME e scegliere Estendi....
Viene visualizzata la finestra Estensione variabile. Aprire la cartella plugins
> org.eclipse.tptp.platform.models_Versione e selezionare
tptp-models.jar, dove Versione è il numero di versione di TPTP.
- Scegliere OK per aggiungere la libreria.
- Aggiungere org.eclipse.emf.common_Versione.jar al percorso di generazione Java, dove
Versione à la versione di EMF.
-
Nella finestra Nuova voce percorso classi di variabili, selezionare la variabile ECLIPSE_HOME e scegliere
Estendi...
- Aprire la cartella plugins e selezionare
org.eclipse.emf.common_Versione.jar, dove Versione è la versione di EMF.
- Scegliere OK per aggiungere la libreria.
- Aggiungere org.eclipse.emf.ecore_Versione.jar al percorso di generazione Java, dove
Versione à la versione di EMF.
- Nella finestra Nuova voce percorso classi di variabili, selezionare la variabile ECLIPSE_HOME e scegliere
Estendi...
- Aprire la cartella plugins e selezionare
org.eclipse.emf.ecore_Versione.jar, dove Versione è la versione di EMF.
- Scegliere OK per aggiungere la libreria.
- Aggiungere org.eclipse.core.runtime_Versione.jar al percorso di generazione Java, dove
Versione à la versione della piattaforma Eclipse.
- Nella finestra Nuova voce percorso classi di variabili, selezionare la variabile ECLIPSE_HOME e scegliere
Estendi...
- Aprire la cartella plugins e selezionare
org.eclipse.core.runtime_Versione.jar, dove Versione è la versione di Eclipse.
- Scegliere OK per aggiungere la libreria.
- Scegliere OK per chiudere la finestra Proprietà.
Utilizzo dell'API del pool di dati
In questa procedura, verranno modificati la classe shoppingCartTest_src
e il metodo testShoppingCartConstructor per utilizzare
shoppingCartDatapool.
- Se richiesto, aprire la prospettiva Java. Dal menu File, scegliere Finestra >
Apri prospettiva > Java.
- Aprire shoppingCartTest_src.java. Nel pannello di selezione, aprire la cartella del progetto datapoolExample
e fare doppio clic su shoppingCartTest_src.java. Il contenuto di shoppingCartTest_src.java viene visualizzato
nell'editor Java.
- Aggiungere le seguenti istruzioni di importazione alla classe shoppingCartTest_src.
import org.eclipse.hyades.models.common.datapool.impl.*;
import org.eclipse.hyades.execution.runtime.datapool.*;
- Dichiarare un'istanza della classe IDatapoolIterator. Questa istanza di classe verrà inizializzata durante l'impostazione del codice e verrà utilizzata nei
metodi di verifica.
public class shoppingCartTest_src extends HyadesTestCase {
IDatapoolIterator dpIterator;
//...
- Modificare il metodo setUp per inizializzare il pool di dati. In un ambiente di verifica TPTP JUnit,
il metodo setUp fornisce un'attrezzatura comune. È possibile utilizzare setUp per inizializzare variabili
di verifica comuni. Nota: specificare il percorso completo dello spazio di lavoro invece di <workspace> nel costruttore
java.io.File.
protected void setUp() throws Exception {
// Inizializza il factory del pool di dati
IDatapoolFactory dpFactory = new Common_DatapoolFactoryImpl();
// Carica il pool di dati shoppingCartDatapool
IDatapool datapool = dpFactory.load(
new java.io.File("<workspace>\\datapoolExample\\shoppingCartDatapool.datapool"),
false);
// Crea un iteratore per visitare il pool di dati
dpIterator = dpFactory.open(datapool,"org.eclipse.hyades.datapool.iterator.DatapoolIteratorSequentialPrivate");
// Inizializza il pool di dati per visitare la prima classe di equivalenza.
dpIterator.dpInitialize(datapool,0);
}
Note:
- Il secondo parametro del metodo di caricamento IDatapoolFactory indica se l'istanza del pool di dati
è condivisa. Se true, la cache del pool di dati viene verificata in cerca di una copia del pool di dati. Se false, il pool di dati viene considerato un'istanza privata. La modifica di un'istanza di pool di dati condivisa, potrebbe influenzare altri utenti, ed è raccomandata
solo in ambienti limitati.
- Se si desidera modificare programmaticamente un pool di dati, importare import org.eclipse.hyades.edit.datapool.
- Il secondo parametro del metodo di apertura IDatapoolFactory rappresenta il tipo di iteratore. Per i pool di dati condivisi, utilizzare DatapoolIteratorSequentialPrivate.
- Modificare il metodo testShoppingCartConstructor per utilizzare shoppingCartDatapool.
public void testShoppingCartConstructor()
throws Exception
{
MyShoppingCart cart = new MyShoppingCart();
// Vista del pool di dati...
// Verifica se il costruttore inizializza ciascun record flower correttamente
while(!dpIterator.dpDone())
{
String Description = dpIterator.dpCurrent().getCell("Description").getStringValue();
double datapoolPrice = dpIterator.dpCurrent().getCell("Price").getDoubleValue();
// Verifica se flower viene calcolato nell'applicazione
Double applicationPrice;
assertNotNull(applicationPrice = (Double)cart.myFlowers.get(Description));
// Verifica che il prezzo dell'applicazione sia uguale al prezzo nel pool di dati
assertTrue(applicationPrice.doubleValue() == datapoolPrice);
dpIterator.dpNext();
}
}
- Salvare shoppingCartTest_src.java. Dal menu File, scegliere File > Salva.
- Aggiungere il pool di dati a testArtifact.
- Aprire la prospettiva Verifica. Nel pannello di selezione fare doppio clic su testDeployment per aprirlo
nell'editor.
- Nella scheda Coppie, selezionare testAsset e scegliere Apri...
- Nella scheda Risorse di verifica, scegliere Aggiungi.... Selezionare il pool di dati e scegliere OK. Salvare la risorsa.
- Eseguire la verifica utilizzando la distribuzione personalizzata.
- Aprire la prospettiva Verifica. In Esplora verifica, selezionare la suite di verifica shoppingCartTest_src con il tasto destro del mouse e
scegliere Esegui come > Esegui.... Viene visualizzata la finestra Esecuzione configurazione.
- Nel riquadro a sinistra della finestra Esecuzione configurazione scegliere la suite di verifica shoppingCartTest_src.
- Nel riquadro a destra della finestra Esecuzione configurazione, selezionare la distribuzione creata nella sezione
Attività preliminari.
- Nella scheda Log di verifica, deselezionare l'opzione Utilizza impostazione predefinita e selezionare la
cartella del progetto datapoolExample.
- Scegliere Esegui per avviare la verifica.
- Fare doppio clic sul nuovo log di verifica shoppingCartTest_src, visualizzato nel pannello di selezione. Viene visualizzato il log di verifica shoppingCartTest_src. Selezionare la scheda Eventi per visualizzare
i dettagli dei risultati della verifica.