Gravando e Executando Testes JUnit

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

Gravando Testes

Criar um projeto "JUnitTest". Agora você pode gravar seu primeiro teste. Implemente o teste em uma subclasse do TestCase. É possível fazer isso usando o assistente de Classe padrão ou o assistente de Etapas de Teste especializado:

  1. Abra o assistente Novo (Arquivo > Novo > Etapas de Teste de JUnit).
  2. Selecione Novo Teste de JUnit 3 e insira "TestFailure" como o nome de sua classe de teste:

    Página 1 do assistente de criação de Etapas de Teste

    Nota: Se desejar usar testes de JUnit 4, certifique-se de que a conformidade de seu compilador esteja configurada para 1.5.

  3. Você verá uma mensagem de aviso solicitando para incluir a biblioteca junit no caminho de construção. Use o link Clique aqui para incluir a biblioteca junit automaticamente.
  4. 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 modelo test. Para isso, posicione o cursor dentro da declaração de classe. Digite "test" seguido por Ctrl+Espaço para ativar o assistente de código e selecione o modelo "test". Altere o nome do método criado para testFailure e chame o método fail().

public void testFailure() throws Exception {
    fail();
}

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

Executando Testes

Para executar TestFailure, pressione o botão de execução na barra de ferramentas. Ele executará automaticamente 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:

Teste com falha

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 de 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 executar novamente seus testes, o ícone de visualização é decorado por um "*" sempre que você alterar o conteúdo da área de trabalho após a execução.

Teste com êxito - Uma execução de teste com êxito
Teste bem-sucedido mas o espaço de trabalho foi alterado - Uma execução de teste bem-sucedida, 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. Selecione Abrir Diálogo de Execução... no menu suspenso Executar na 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 com falha na guia Falhas 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 as etapas de teste e execute  Depurar Como>Teste de JUnit a partir do menu suspenso Depuração.

Uma configuração de ativação JUnit possui uma opção "manter ativo". Se a sua máquina virtual Java suporta a "substituição de código ativo" é possível corrigir o código e executar novamente o teste sem reiniciar a execução do teste integral. Para ativar esta opção, selecione a caixa de seleção Manter a execução do JUnit após uma execução de teste ao depurar na configuração de ativação do JUnit.

Criando um Conjunto de Testes

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

  1. Abrir o assistente Novo
  2. Selecione Java > JUnit > Conjunto de Teste de JUnit e clique em Avançar.
  3. Digite um nome para sua classe de conjuntos de teste (a convenção é para usar "AllTests" que aparecem por padrão).

    Assistente do Conjunto de Testes

  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.