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 a ler este guia de iniciação, terá de:
-
Instalar o Eclipse e a a Plataforma de Ferramentas de Teste e Desempenho
do Eclipse (TPTP - Eclipse Test and Performance Tools Platform).
- Ter um conhecimento básico sobre os testes JUnit. Para mais informações
sobre os testes JUnit, consulte www.junit.org.
- 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:
- Criar uma amostra de uma aplicação do utilizador
- Configurar uma série de testes da TPTP
- Criar um conjunto de dados e inicializar dados de teste
- Modificar casos de testes para referenciar um
conjunto de dados
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.
- 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.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
-
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.
- Abra a Perspectiva de Teste e crie uma implementação de teste.
Para ver um exemplo, consulte Criar uma
Implementação de Teste.
-
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.
- 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.

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).
- 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.
- 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.
- 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.
- Na lista de selecção de Assistentes, expanda a pasta Recursos de Teste e seleccione Conjunto de Dados.
- Fazer clique em Seguinte Aparecerá o diálogo Novo Conjunto de Dados.
- 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).
- 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.
- 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.
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.
- Abra a Perspectiva Java. No menu Ficheiro, seleccione Janela >
Abrir Perspectiva > Java.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Caso seja requerido, abra a Perspectiva Java. No menu Ficheiro, seleccione Janela >
Abrir Perspectiva > 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.
- 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.*;
- 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;
//...
- 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.
- 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();
}
}
- Guardar o shoppingCartTest_src.java. No menu Ficheiro, escolha Ficheiro
> Guardar.
- 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.
- 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.
- 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.