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 incluir 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 (no menu de contexto do projeto, escolha Propriedades > Caminho de Construção Java)
  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 > Etapa de Teste do JUnit).
  2. Insira "TestFailure" como o nome da classe do teste:

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

  3. Clique em Concluir 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(). Altere também o modificador de visibilidade de forma que o método de teste torne-se público.

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 > Teste JUnit. É possível inspecionar os resultados do teste na visualização JUnit. Esta visualização mostra o progresso e o status da execução do teste:

Falha no teste

A visualização é mostrada na perspectiva atual sempre que uma execução de teste é iniciada. Uma disposição conveniente para a visualização JUnit é acoplá-la como uma visualização rápida. A visualizaçã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 visualização JUnit como uma visualizaçã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 visualizaçã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 visualização JUnit não aparece, mas o indicador de êxito é mostrado no ícone da visualizaçã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 visualizaçã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 caminho de classe 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 visualizaçã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 > Conjunto de Teste JUnit 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 do Conjunto de Teste

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

É possível incluir 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.

Avisos Legais