Iniciação: Aceder a um conjunto de dados a partir de um teste JUnit


Objectivos:

Para criar e aceder a um conjunto de dados a partir de um exemplo de uma aplicação de teste através da utilização da Plataforma de Ferramentas de Teste e Desempenho do Eclipse (TPTP - Eclipse Test and Performance Tools Platform).

Tempo necessário

1 hora

Antes de começar

Antes de começar a ler este guia de iniciação, terá de:

  1. Instalar o Eclipse e a a Plataforma de Ferramentas de Teste e Desempenho do Eclipse (TPTP - Eclipse Test and Performance Tools Platform).
  2. Ter um conhecimento básico sobre os testes JUnit. Para mais informações sobre os testes JUnit, consulte www.junit.org.
  3. Configurar e executar o Controlador de Agentes correspondente à sua versão da TPTP. Para mais informações, consulte Como começar com o Controlador de Agentes.


Descrição

Nesta iniciação, cria-se e testa-se uma aplicação denominada MyShoppingCart. Ao utilizar a Plataforma de Ferramentas de Teste e Desempenho do Eclipse (TPTP - Eclipse Test and Performance Tools Platform), desenvolvem-se testes JUnit e cria-se um conjunto de dados para fornecer dados ao ambiente de teste.

Esta iniciação guia-o através dos seguintes procedimentos:

  1. Criar uma amostra de uma aplicação do utilizador
  2. Configurar uma série de testes da TPTP
  3. Criar um conjunto de dados e inicializar dados de teste
  4. Modificar casos de testes para referenciar um conjunto de dados

Criar uma amostra de uma aplicação do utilizador


Neste procedimento, desenvolve-se uma classe MyShoppingCart. Nos procedimentos seguintes, utiliza-se a a Plataforma de Ferramentas de Teste e Desempenho do Eclipse para desenvolver um ambiente de teste correspondente.
  1. Criar um novo Projecto Java Eclipse.
    • No menu Ficheiro, escolha Ficheiro > Novo > Projecto... Aparecerá o diálogo Novo Projecto.
    • Na lista dos Assistentes, seleccione Projecto Java e faça clique em Seguinte. Aparecerá a página Criar um projecto Java.
    • Escreva datapoolExample para nome do projecto e faça clique em Terminar. O projecto datapoolExample surge na vista Navegador.
  2. Criar uma classe MyShoppingCart.
    • Na vista Navegador, faça clique com o botão direito do rato no projecto datapoolExample e escolha Novo > Classe. Aparecerá o diálogo Nova Classe Java.
    • Escreva MyShoppingCart no campo Nome.
    • Limpe a opção para criar o método principal public static void main(String[] args).
    • Faça clique em Terminar. O ficheiro MyShoppingCart.java surge no editor Java.
    • Escreva o seguinte para a origem do 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;	    	 	    	 	     		
      	}
      }
    • Guardar MyShoppingCart.java. No menu Ficheiro, escolha Ficheiro > Guardar.

Configurar uma série de testes TPTP


Neste procedimento, desenvolve-se uma série de testes para a classe MyShoppingCart. Ao utilizar a a Plataforma de Ferramentas de Teste e Desempenho do Eclipse, desenvolve-se um teste JUnit para o método itemCost.
  1. Abrir a Perspectiva de Teste.
    • No menu Ficheiro, escolha Janela > Abrir Perspectiva > Outro.
    • Seleccione Teste e faça clique em OK. Aparecerá o Navegador de Teste.
  2. Criar um novo Teste de JUnit TPTP.
    • No Navegador de Testes, faça clique com o botão direito do rato no projecto datapoolExample e escolha Novo > Elemento Teste...
    • No diálogo do Elemento Teste, seleccione teste JUnit TPTP e faça clique em Seguinte. Aparecerá o diálogo Novo Caso de Teste, pedindo-lhe que adicione bibliotecas JUnit. Faça clique em Sim para adicionar as bibliotecas JUnit.
    • Na página Novo Código Fonte de Testes JUnit, escreva shoppingCartTest_src no campo Nome. Na secção Seleccionar a forma de edição do comportamento do teste, escolha a opção editar No editor teste (a predefinida).
    • Faça clique em Terminar. Aparecerá o editor Teste de JUnit TPTP, que mostrará a série de testes shoppingCartTest_src. O separador Descrição Geral inclui uma descrição de teste, Informações de Origem e uma lista de Métodos de Teste. Neste momento, não estão definidos modelos de teste. Para esta iniciação, o editor Testes JUnit TPTP gera apêndices de método, para que a opção Implementar Comportamento de Teste como código na secção Informações de Origem seja limpa. Para mais informações, consulte Editor Série de Testes JUnit.
  3. Adicionar os métodos testItemCost e testShoppingCartConstructor.
    • No separador Métodos de Teste, faça clique em Adicionar. Aparecerá um nome predefinido para o seu teste.
    • Adicione o método testItemCost. No campo Nome, escreva testItemCost para o novo nome do teste. No campo Descrição, escreva Test for the MyShoppingCart.itemCost(String, int) method.
    • Adicione o método testShoppingCartConstructor. No separador Métodos de Teste, faça clique em Adicionar. No campo Nome, escreva testShoppingCartConstructor para o novo nome do teste. No campo Descrição, escreva Test for the MyShoppingCart constructor.
  4. Configurar o comportamento da execução do teste.
    • Adicione um ciclo de execução de testes. No separador Comportamento, faça clique em Adicionar.. > Ciclo. No campo Nome, escreva Loop_MyShoppingCart. No campo Número de Iterações, escreva 1 (o valor predefinido).
    • Adicione uma invocação testShoppingCartConstructor. Seleccione Loop_MyShoppingCart e faça clique em Adicionar... > invocação. Aparecerá o diálogo Invocação de Teste. Seleccione testShoppingCartConstructor e faça clique em OK.
    • Adicione uma inovação testItemCost. Seleccione Loop_MyShoppingCart e faça clique em Adicionar... > invocação. Aparecerá o diálogo Invocação de Teste. Seleccione testItemCost e faça clique em OK.
    • Guarde a série de teste. No menu Ficheiro, escolha Ficheiro > Guardar.

      Nota: o comando Guardar leva a que o editor Teste do JUnit TPTP crie apêndices de método de teste em shoppingCartTest_src.java.
  5. Introduza o código para os métodos de teste JUnit gerados testShoppingCartConstructor e testItemCost.
    • Abra a Perspectiva Java. No menu Ficheiro, escolha Janela > Abrir Perspectiva > Outro... > Java.
    • Abra shoppingCartTest_src.java. No Navegador, abra a pasta do projecto datapoolExample e faça duplo clique em shoppingCartTest_src.java. Os conteúdos de shoppingCartTest_src.java aparecerão no editor Java, incluindo o código para configurar e executar a série de testes e métodos apêndices para testShoppingCartConstructor e testItemCost.
    • Escreva o seguinte código para o método 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);
      }
    • Escreva o seguinte código para o método testItemCost.
      public void testItemCost()
      throws Exception
      {
      	MyShoppingCart cart = new MyShoppingCart();
      	double priceForTwo = cart.itemCost("Orchid", 2);
      	
      	assertTrue(priceForTwo == 11.98);
      }
    • Guarde o shoppingCartTest_src.java. No menu Ficheiro, escolha Ficheiro > Guardar.
  6. Abra a Perspectiva de Teste e crie uma implementação de teste. Para ver um exemplo, consulte Criar uma Implementação de Teste.
  7. Execute o teste através da utilização da sua implementação personalizada.
    • No Navegador de Teste, faça clique com o botão direito do rato na série de testes shoppingCartTest_src e escolha Executar Como > Executar.... Aparecerá o diálogo de configuração Executar.
    • Na área da janela Configurações, seleccione Teste e faça clique em Novo.
    • Na área da janela esquerda da configuração Executar (Seleccionar teste a executar), expanda datapoolExample e escolha a série de testes shoppingCartTest_src.
    • Na área da janela direita da configuração Executar, seleccione a secção da implementação que criou.
    • No separador Registo de Testes, desmarque a opção Utilizar predefinições e seleccione a pasta do projecto datapoolExample para a localização.
    • Faça clique em Executar para lançar o teste.
  8. Faça duplo clique no registo de testes shoppingCartTest_src, que aparece no Navegador de Testes. Aparecerá o registo de testes shoppingCartTest_src. Seleccione o separador Eventos para ver os detalhes do teste.Deverá ver os seguintes eventos:início de série de testes, início de Loop_MyShoppingCart, início de teste, veredicto de teste, fim de teste, início de segundo teste, veredicto de segundo teste, fim de segundo teste, fim de ciclo, veredicto de série de testes e fim de série de testes.

Criar um conjunto de dados e inicializar dados de teste


Neste procedimento, cria-se um conjunto de dados simples para armazenar dados de teste. Ao utilizar o editor conjunto de dados, define elementos estruturais de um conjunto de dados, incluindo variáveis (colunas), registos (linhas) e classes equivalentes (grupos de registos relacionados).
  1. Crie um ficheiro CSV (comma-delimited - delimitado por vírgulas) que inclua os dados do seu teste.Geralmente, pode exportar dados de uma aplicação de folha de cálculo ou de uma base de dados para o formato CSV. Contudo, nesta Iniciação os dados são escritos num editor de texto.
    • Escreva o seguinte num editor de texto.
      ,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
    • Guarde o ficheiro como flowerData.csv numa localização externa temporária.
  2. No Eclipse, abra a Perspectiva de Teste.
    • No menu Ficheiro, escolha Janela > Abrir Perspectiva > Outro.
    • Seleccione Teste e faça clique em OK. Aparecerá o Navegador de Teste.
  3. No Navegador de Testes, faça clique com o botão direito do rato num projecto e seleccione Novo > Elemento de Testet... Aparecerá o diálogo Novo Elemento de Teste.
  4. Na lista de selecção de Assistentes, expanda a pasta Recursos de Teste e seleccione Conjunto de Dados.
  5. Fazer clique em Seguinte Aparecerá o diálogo Novo Conjunto de Dados.
  6. Escolha a pasta do projecto e o nome do conjunto de dados. Na lista de projectos existentes, seleccione o projecto datapoolExample. No campo Nome, escreva shoppingCartDatapool. Faça clique em Seguinte para continuar e de novo em Seguinte para abrir a página de importação de ficheiros CSV (comma-delimited - delimitado por vírgulas).
  7. Importe o ficheiro CSV flowerData.csv.
    • No campo Ficheiro CSV, faça clique em Procurar e navegue para flowerData.csv.
    • Marque a opção A primeira linha contém nomes e tipos sugeridos de variáveis. A primeira linha do ficheiro flowerData.csv contém títulos e tipos de colunas.
    • Marque a opção A primeira coluna contém nomes de classes de equivalências. Dados relacionados com o grupo classes de equivalência. A primeira coluna do ficheiro flowerData.csv especifica uma única classe de equivalência denominada flowers.
  8. Faça clique em Terminar. Aparecerá um diálogo se tiver especificado as dimensões iniciais do conjunto de dados, que poderão entrar em conflito com as dimensões do ficheiro CSV. Faça clique em Sim para utilizar as dimensões do ficheiro CSV. Faça clique em Não para utilizar as dimensões iniciais especificadas (e possivelmente truncar os dados do ficheiro CSV). Aparecerá o editor Conjunto de Dados, que mostrará os dados contidos na classe de equivalência flowers.

    Para informações detalhadas sobre como criar um conjunto de dados, consulte Criar um conjunto de dados.


Modificar casos de testes para fazer referência a um conjunto de dados


Neste procedimento, utilize o conjunto de dados API para voltar a colocar os valores de teste codificados permanentemente com referências a colunas de conjuntos de dados.

Adicionar bibliotecas requeridas pelo conjunto de dados API

O conjunto de dados API requer várias bibliotecas da TPTP e da Estrutura de Modelação do Eclipse (EMF). Neste procedimento, adicionam-se as bibliotecas ao caminho de construção Java.
  1. Abra a Perspectiva Java. No menu Ficheiro, seleccione Janela > Abrir Perspectiva > Java.
  2. Abra as propriedades do projecto datapoolExample. Na janela Navegador ou Explorador de Pacotes, faça clique com o botão direito do rato na pasta do projecto datapoolExample e escolha as propriedades. Aparecerá o diálogo Propriedades do datapoolExample.
  3. Adicione tptp-models.jar ao caminho de construção Java.
    • Na área da janela esquerda, seleccione Caminho de Construção Java.
    • Na área da janela direita, seleccione o separador Bibliotecas e faça clique em Adicionar Variável... Aparecerá o diálogo Nova Variável de Entrada de Caminho de Classes.
    • Seleccione a variável ECLIPSE_HOME e faça clique em Expandir... Aparecerá o diálogo Expansão de Variável. Abra a pasta plugins > org.eclipse.tptp.platform.models_Version e seleccione tptp-models.jar, no qual Version é o seu número da versão TPTP.
    • Faça clique em OK para adicionar a biblioteca.
  4. Adicione org.eclipse.emf.common_Version.jar ao caminho de construção Java, no qual Version é a sua versão EMF.
    • No diálogo Nova Variável de entrada do Caminho de Classes, seleccione a variável ECLIPSE_HOME e faça clique em Expandir...
    • Abra a pasta de plug-ins e seleccione org.eclipse.emf.common_Version.jar, no qual Version é a sua versão do EMF.
    • Faça clique em OK para adicionar a biblioteca.
  5. Adicione org.eclipse.emf.ecore_Version.jar ao caminho de construção Java, no qual Version é a sua versão EMF.
    • No diálogo Nova Variável de entrada do Caminho de Classes, seleccione a variável ECLIPSE_HOME e faça clique em Expandir...
    • Abra a pasta de plug-ins e seleccione org.eclipse.emf.ecore_Version.jar, no qual Version é a sua versão EMF.
    • Faça clique em OK para adicionar a biblioteca.
  6. Adicione org.eclipse.core.runtime_Version.jar ao caminho de construção Java, no qual Version é a sua versão da plataforma Eclipse.
    • No diálogo Nova Variável de entrada do Caminho de Classes, seleccione a variável ECLIPSE_HOME e faça clique em Expandir...
    • Abra a pasta de plug-ins e seleccione org.eclipse.core.runtime_Version.jar, no qual Version é a sua versão da plataforma Eclipse.
    • Faça clique em OK para adicionar a biblioteca.
  7. Faça clique em OK para fechar o diálogo Propriedades.


Utilizar o conjunto de dados API

Neste procedimento, modificam-se os métodos shoppingCartTest_src class e testShoppingCartConstructor para utilizar o shoppingCartDatapool.
  1. Caso seja requerido, abra a Perspectiva Java. No menu Ficheiro, seleccione Janela > Abrir Perspectiva > Java.
  2. Abra shoppingCartTest_src.java. No Navegador, abra a pasta do projecto datapoolExample e faça duplo clique em shoppingCartTest_src.java. Os conteúdos de shoppingCartTest_src.java aparecerão no editor Java.
  3. Adicione os seguintes instruções de importação à classe shoppingCartTest_src.
    import org.eclipse.hyades.models.common.datapool.impl.*; import
    org.eclipse.hyades.execution.runtime.datapool.*;
  4. Declare uma instância de classe IDatapoolIterator. Esta instância de classe será inicializada no seu código de configuração e utilizada em métodos de teste.
    public class shoppingCartTest_src extends HyadesTestCase {
    	
    	IDatapoolIterator dpIterator;
    	
    	//...
  5. Modifique o método setUp para inicializar o seu conjunto de dados. Num ambiente de teste do JUnit TPTP, o método setUp faculta um acessório comum. Pode utilizar o setUp para inicializar variáveis de testes comuns.Nota: especifique o seu caminho do espaço de trabalho absolutamente qualificado em vez de <workspace> no construtor java.io.File.
    protected void setUp() throws Exception {
    	// Initialize the datapool factory
    	IDatapoolFactory dpFactory = new Common_DatapoolFactoryImpl();
    		
    	// Load the shoppingCartDatapool datapool 
    	IDatapool datapool = dpFactory.load(
    			new java.io.File("<workspace>\\datapoolExample\\shoppingCartDatapool.datapool"),
    			false);
    		   
    	// Create an iterator to traverse the datapool
    	dpIterator = dpFactory.open(datapool,"org.eclipse.hyades.datapool.iterator.DatapoolIteratorSequentialPrivate");
    	
    	// Initialize the datapool to traverse the first equivalence class.
    	dpIterator.dpInitialize(datapool,0);
    }
    Notas:
    • O segundo parâmetro no método de carregamento IDatapoolFactory indica se a instância do conjunto de dados é partilhado.Se for verdadeiro, é verificado se o conjunto de dados cache tem uma cópia do conjunto de dados. Se for falso, o conjunto de dados é uma instância privada.Modificar uma instância de conjunto de dados partilhada poderá afectar outros utilizadores e é apenas recomendado em ambientes confinados.
    • Se pretender editar programaticamente um conjunto de dados, importe org.eclipse.hyades.edit.datapool.
    • O segundo parâmetro no método aberto IDatapoolFactory representa o tipo de agente iterativo. Para conjuntos de dados partilhados, utilize DatapoolIteratorSequentialPrivate.
  6. Modificar o método testShoppingCartConstructor para utilizar o shoppingCartDatapool.
    public void testShoppingCartConstructor()
    throws Exception
    {
    	MyShoppingCart cart = new MyShoppingCart();
    		
    	// Traverse through datapool...
    	// Test if constructor initializes each flower record appropriately
    	while(!dpIterator.dpDone())
    	{
    		String Description = dpIterator.dpCurrent().getCell("Description").getStringValue();
    		double datapoolPrice = dpIterator.dpCurrent().getCell("Price").getDoubleValue();
    		
    		// Test if the flower is accounted for in the application
    		Double applicationPrice;
    		assertNotNull(applicationPrice = (Double)cart.myFlowers.get(Description));
    		
    		// Test that the application price equals the price in the datapool 
    		assertTrue(applicationPrice.doubleValue() == datapoolPrice);
    		
    		dpIterator.dpNext();
    	}
    }
  7. Guardar o shoppingCartTest_src.java. No menu Ficheiro, escolha Ficheiro > Guardar.
  8. Adicione o conjunto de dados ao seu testArtifact.
    • Abrir a Perspectiva de Teste. No Navegador de Teste, faça duplo clique em testDeployment para o abrir no editor.
    • No separador Pares, seleccione testAsset e faça clique em Abrir...
    • No separador Recursos de Teste, faça clique em Adicionar.... Seleccione o conjunto de dados e faça clique em OK. Guarde o recurso.
  9. Execute o teste através da utilização da sua implementação personalizada.
    • Abrir a Perspectiva de Teste. No Navegador de Teste, faça clique com o botão direito do rato na série de testes shoppingCartTest_src e escolha Executar Como > Executar.... Aparecerá o diálogo de configuração Executar.
    • Na área da janela esquerda da configuração Executar, escolha a série de testes shoppingCartTest_src.
    • Na área da janela direita da configuração Executar, seleccione a implementação que criou na secção Antes de Começar.
    • No separador Registo de Testes, desmarque a opção Utilizar predefinições e seleccione a pasta do projecto datapoolExample para a localização.
    • Faça clique em Executar para lançar o teste.
  10. Faça duplo clique no novo registo de testes shoppingCartTest_src, que aparece no Navegador de Teste. Aparecerá o registo de testes shoppingCartTest_src. Seleccione o separador Eventos para ver os detalhes do resultado do teste.


Conceitos relacionados
Tarefas e conceitos de teste comuns

Tarefas relacionadas
Criar uma Implementação de Teste
Facultar dados variáveis aos testes
Criar um teste JUnit manualmente

(C) Copyright IBM Corporation 2000, 2006. Todos os direitos reservados.