Testes com JUnit 4

JUnit é um framework open-source, criado por Eric Gamma e Kent Beck, com suporte à criação de testes automatizados na linguagem de programação Java.

Esse framework facilita a criação de código para a automação de testes com apresentação dos resultados. Com ele, pode ser verificado se cada método de uma classe funciona da forma esperada, exibindo possíveis erros ou falhas podendo ser utilizado tanto para a execução de baterias de testes.

Com JUnit, o programador tem uma ferramenta que o ajudará a eliminar os erros de seu código de maneira mais atraente. Pois, se criou uma forma interessante de realizar testes onde é possível a criação de programas que realizem os testes pelo programador. É utilizando esse conceito que JUnit permite deixar a fase de teste de unidades bem mais agradável ao programador.

O teste de unidade testa o menor dos componentes de um sistema de maneira isolada(cada teste pode ser executado independentemente). Cada uma dessas unidades define um conjunto de estímulos (chamada de métodos), e de dados de entrada e saída associados a cada estímulo. As entradas são parâmetros e as saídas são o valor de retorno, exceções ou o estado do objeto.

Tipicamente um teste unitário executa um método individualmente e compara uma saída conhecida após o processamento da mesma. Por exemplo:

   Assert.assertEquals(2 == algumMetodo(1)); 

A expressão acima verifica se a saída de algumMetodo() é 2 quando esse método recebe o parâmetro 1. Normalmente o desenvolvedor já realiza testes semelhantes a esse pequeno exemplo, o que é chamado de testes unitários em linha. Assim sendo, o conceito chave de um teste de unidade é exercitar um código e qual o resultado esperado.

O JUnit permite a realização de Teste unitário “caixa branca”, facilitando assim a correção de métodos e objetos.

Em sua versão mais atual(JUnit 4.?), o JUnit permite a utilização de anotações para a especificação de casos de teste:

  • @Test. Principal anotação. Indica que o método anotado contém testes.
  • @Before. Identifica método a ser executado antes da execução de todo método de teste. Ou seja, será executado quantas vezes forem o número de métodos de teste (uma vez antes de cada teste). Efeito simétrico à anotação @After.
  • @BeforeClass. Identifica método static que será executado uma única vez por instância da classe que contém os testes e antes da execução de qualquer método de teste. Efeito simétrico ao da anotação @AfterClass.
  • @After. Identifica método para ser executado após cada método de teste, indicado pela anotação @Test. Efeito simétrico à anotação @Before.
  • @AfterClass. Identifica método static para ser executado após a execução de todos os métodos de teste da classe em questão. Ou seja, é executado uma única vez para cada instância da classe de teste, após a execução de todos os métodos de teste.

* todas as anotações junit são anotações de método

Exemplo de aplicações da anotações:
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
 
public class Anotacoes {
 
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("Uma única vez antes de qualquer teste");
    }
 
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("Uma única vez após todos os testes");
    }
 
    @Before
    public void setUp() throws Exception {
        System.out.println("Antes de todo teste");
    }
 
    @After
    public void tearDown() throws Exception {
        System.out.println("Após todo teste");
    }
 
    @Test
    public void testSimples() {
        System.out.println("Teste propriamente dito");
    }
 
    @Test(expected=Exception.class)
    public void testOutro() throws Exception {
        System.out.println("Um outro teste");
        throw new Exception();
    }
}

As verificações (asserções) de resultados esperados são realizadas através da classe org.junit.Assert. A classe provê vários métodos para verifação de valores, explore-os. Verificações de exceções lançadas são feitas através do atributo expected da annotação @Test (@Test=expected=ClasseException.class).

Exemplos
import org.junit.Assert;
import org.junit.Test;
import org.junit.Before;
import org.junit.After;
 
// Não necessita herdar nada.
public class SampleTest {
 
 private java.util.List<Object> listaVazia;
 
 /**
  * Este método será chamado antes de cada método de teste.
  */
 @Before
 protected void inicializar() {
	 listaVazia = new java.util.ArrayList<Object>();
 }    
 
 /**
  * Após cada método de teste, este método é invocado para limpar o lixo.
  */
 @After
 protected void terminou() {
	 listaVazia = null;
 }
 
 /**
  * O método testComportamento faz uma chamada ao método assertEquals(mensagem, valor
  * esperado, valor atual) que verfica se o resultado de "listaVazia.size()" (tamanho da
  * lista) é igual a 0 (zero) que é o valor esperado, caso contrário emite a mensagem.
  */
 @Test
 public void testComportamento() {
	 Assert.assertEquals("A lista vazia deve ter 0 elementos", 0, listaVazia.size());
 }
 
 /**
  * Este método está testando a exceção. Ela deve ser lançada, pois não existe
  * nenhum item na lista. Caso contrário a implementação tem problemas.
  */
 @Test(expected=IndexOutOfBoundsException.class)
 public void lancarException() {
	 listaVazia.get(0);
 }
}

Links (por favor, leiam)
Ferramentas complementares
 
/var/www/html/wiki/data/pages/quickstart/testes_com_junit_4.txt · Última modificação: 2010/05/15 19:36 (edição externa)
 
Exceto onde for informado ao contrário, o conteúdo neste wiki está sob a seguinte licença:CC Attribution-Noncommercial-Share Alike 3.0 Unported
Recent changes RSS feed Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki