Gravando e executando testes JUnit

Nesta seção, você utilizará a estrutura de teste JUnit para gravar e executar testes. Para obter uma introdução ao JUnit, você pode consultar o JUnit Cookbook.

Gravando Testes

Para que você possa gravar testes JUnit, é preciso adicionar a biblioteca junit.jar ao caminho de classe da construção. A instalação do Eclipse inclui o JUnit no plug-in org.junit:

  1. Crie um projeto "JUnitTest"
  2. Abra a página de propriedade do caminho de construção do projeto
  3. Alterne para a guia Bibliotecas
  4. Adicione o junit.jar, contido no org.junit do diretório de plug-ins, como um JAR externo para seu projeto.
Opcionalmente, se quiser procurar a origem do JUnit, anexe o junitsrc.zip ao junit.jar. O zip da origem está localizado no plug-in org.eclipse.jdt.source em src/org.junit_3.8.1.

Agora que o projeto JUnitTest tem acesso às classes do JUnit, você pode gravar seu primeiro teste. Implemente o teste em uma subclasse do TestCase. Você pode fazer isto, utilizando o assistente Classe padrão ou o assistente Etapas de Teste especializado:

  1. Abra o assistente Novo (Arquivo > Novo > Outros...)
  2. Selecione Java > JUnit na área de janela esquerda e TestCase na área de janela direita e clique em Avançar.
  3. Insira "TestFailure" como o nome da classe do teste:

    Página 1 do assistente para criação do TestCase

  4. Clique em Finalizar para criar a classe do teste.

Adicione um método de teste com defeito à classe TestFailure. Um modo rápido de inserir um método de teste é com o gabarito test. Para fazer isto, digite "test" seguido por Ctrl+Espaço para ativar a assistência ao código e selecione o gabarito "test". Altere o nome do método criado para testFailure e chame o método fail().

public void testFailure() {
    fail();
}

Agora você está pronto para executar seu primeiro teste.

Executando Testes

Para executar TestFailure, ative o menu drop down Executar na barra de ferramentas e selecione Executar como > JUnit Test. É possível inspecionar os resultados do teste na exibição JUnit. Esta exibição mostra o progresso e o status da execução do teste:

Teste com defeito

A exibição é mostrada na perspectiva atual sempre que uma execução de teste é iniciada. Uma disposição conveniente para a exibição JUnit é acoplá-la como uma exibição rápida. A exibição JUnit possui duas guias: uma mostra uma lista dos defeitos e a outra mostra o conjunto de testes completo como uma árvore. É possível navegar de um defeito até a origem correspondente dando um clique duplo na linha correspondente do rastreio do defeito.

Acople a exibição JUnit como uma exibição rápida, remova a instrução fail() no método testFailure() para que o teste seja aprovado e execute novamente o teste. Para executar o teste novamente, clique no botão Executar novamente na barra de ferramentas da exibição ou para executar novamente o programa que foi ativado mais recentemente, ative o drop down Executar. Dessa vez o teste deverá obter êxito. Como o teste obteve êxito, a exibição JUnit não aparece, mas o indicador de êxito é mostrado no ícone da exibição JUnit e a linha de status mostra o resultado do teste. Como um lembrete para que você execute seus testes novamente, o ícone da exibição é decorado com um "*" toda vez que o conteúdo do espaço de trabalho é alterado após a execução.

Teste com êxito - Uma execução de teste com êxito
Teste com êxito mas o espaço de trabalho foi alterado - Uma execução de teste com êxito, mas o conteúdo do espaço de trabalho foi alterado desde a última execução de teste.

Além de executar uma etapa do teste conforme descrito anteriormente, você também pode:

Personalizando uma Configuração de Teste

Quando desejar transmitir parâmetros ou personalizar as definições de uma execução de teste, abra o Diálogo Configuração da Ativação. SelecioneExecutar....no menu drop down Executar da barra de ferramentas:

Configuração de Ativação do JUnit

Neste diálogo, você pode especificar o teste a ser executado, seus argumentos, seu classpath de tempo de execução e o ambiente de tempo de execução Java.

Depurando uma Falha no Teste

No caso de uma falha no teste, você pode seguir estas etapas para depurá-la:

  1. Dê um clique duplo na entrada do defeito no rastreio da pilha na exibição JUnit, para abrir o arquivo correspondente no editor.
  2. Defina um ponto de interrupção no início do método de teste.
  3. Selecione a etapa do teste e execute  Depurar Como>Teste do JUnit no drop down Depurar.

Uma configuração de ativação do JUnit tem uma opção "manter ativo". Se sua máquina virtual Java suportar "substituição automática de código", você pode corrigir o código e executar o teste novamente sem reiniciar a execução completa do teste. Para ativar esta opção, selecione a caixa de opções Manter em execução o JUnit após uma execução de teste na depuração na configuração de ativação do JUnit.

Criando um Conjunto de Testes

O assistente TestSuite do JUnit ajuda na criação de um conjunto de testes. Você pode selecionar o conjunto de classes que devem pertencer ao conjunto.

  1. Abrir o assistente Novo
  2. Selecione Java > JUnit na área de janela esquerda e TestSuite na área de janela direita e clique em Avançar.
  3. Informe um nome para a classe do conjunto de testes (a convenção é utilizar "AllTests", que aparece por padrão).

    Assistente Teste Suite

  4. Selecione as classes a serem incluídas no conjunto. Atualmente, há somente uma única classe de teste, mas, posteriormente, é possível adicionar ao conjunto.

É possível adicionar ou remover classes de teste do conjunto de testes de duas maneiras:

Nota: o assistente coloca 2 marcadores, //$JUnit-BEGIN$ e //$JUnit-END$, na classe do conjunto de Testes criado, que permite que o assistente atualize as classes existentes do conjunto de testes. Não é recomendada a edição de códigos entre os marcadores.

Copyright (c) 2000, 2003 IBM Corporation e outros. Todos os Direitos Reservados.