Esercitazione: Accesso a un pool di dati da una verifica JUnit


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

Attività preliminari

Prima di iniziare l'esercitazione è necessario:

  1. Installare Eclipse e TPTP (Test and Performance Tools).
  2. Conoscere le procedure di verifica JUnit. Per ulteriori informazioni sulla verifica JUnit, fare riferimento a www.junit.org.
  3. 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:

  1. Creazione di un'applicazione utente di esempio
  2. Impostazione di una suite di verifica TPTP
  3. Creazione di un pool di dati e inizializzazione dei dati di verifica
  4. Modifica dei casi di prova per fare riferimento a un pool di dati

Creazione di un'applicazione utente di esempio


In questa procedura viene sviluppata la classe MyShoppingCart. Nelle procedure successive, verrò utilizzato TPTP per sviluppare l'ambiente di verifica corrispondente.
  1. 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.
  2. 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.

Impostazione di una suite di verifica TPTP


In questa procedura viene sviluppata una suite di verifica per la classe MyShoppingCart. Utilizzando TPTP, verrà sviluppata una verifica JUnit per il metodo itemCost.
  1. Aprire la prospettiva Verifica.
    • Dal menu File, scegliere Finestra > Apri prospettiva > Altro.
    • Selezionare Verifica e scegliere OK. Viene visualizzata la finestra Esplora verifica.
  2. 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 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.
  3. 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.
  4. 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.
  5. 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.
  6. Aprire la prospettiva Verifica e creare una distribuzione di verifica. Per un esempio, fare riferimento alla sezione Creazione di una distribuzione di verifica.
  7. 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.
  8. 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.

Creazione di un pool di dati e inizializzazione dei dati 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).
  1. 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.
  2. 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.
  3. 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.
  4. Nell'elenco delle procedure guidate, espandere la cartella Risorse di verifica e selezionare Pool di dati.
  5. Fare clic su Avanti. Viene visualizzata la finestra Nuovo pool di dati.
  6. 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.
  7. 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.
  8. 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 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.


Modifica dei casi di prova per fare riferimento a 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.
  1. Aprire la prospettiva Java. Dal menu File, scegliere Finestra > Apri prospettiva > Java.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  1. Se richiesto, aprire la prospettiva Java. Dal menu File, scegliere Finestra > Apri prospettiva > Java.
  2. 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.
  3. 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.*;
  4. 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;
    	
    	//...
  5. 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.
  6. 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();
    	}
    }
  7. Salvare shoppingCartTest_src.java. Dal menu File, scegliere File > Salva.
  8. 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.
  9. 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.
  10. 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.


Argomenti correlati
Attività e concetti comuni sulle verifiche

Attività correlate
Creazione di una distribuzione di verifica
Verifiche con dati variabili
Creazione manuale di una verifica JUnit

(C) Copyright IBM Corporation 2000, 2006. Tutti i diritti riservati.