JUnit #2

Continuando a falar sobre o JUnit, agora vamos ver algumas anotações que podem ser utilizadas para preparações antes de rodar os testes (como abertura de conexões, por exemplo) ou para ações a serem realizadas após o fim dos testes (como fechamento de conexões, por exemplo).

@Before deve ser usado como anotação acima do método que tenha o que deve ser executado antes de qualquer um dos casos de teste. Se forem rodados 5 testes, por exemplo, o método com @Before será executado 5 vezes, uma antes de cada um deles.

@After deve ser usado como anotação acima do método que tenha o que deve ser executado depois de qualquer um dos casos de teste. Se forem rodados 5 testes, por exemplo, o método com @After será executado 5 vezes, uma depois de cada um deles.

@BeforeClass deve ser usado como anotação acima do método que tenha o que deve ser executado uma única vez antes dos casos de teste da classe. Não importa quantos casos de testes haja, o método com @BeforeClass será executado apenas uma vez, antes que comecem os casos de teste.

@AfterClass deve ser usado como anotação acima do método que tenha o que deve ser executado uma única vez depois dos casos de teste da classe. Não importa quantos casos de testes haja, o método com @AfterClass será executado apenas uma vez, depois que terminarem todos os casos de teste da classe.

JUnit #1

O JUnit é um framework java de código aberto para gerar testes unitários. Ele normalmente já possui seu ".jar" incluído na maioria das IDEs populares. Através dele, classes de teste podem ser criadas e nestas classes casos de teste podem construídos para testar de maneira automatizada as classes alvo.

Para cada método da classe-alvo que se desejar testar é criado um caso de teste.

Nesses casos de teste o desenvolvedor define quais serão os dados a serem utilizados como entrada no método a ser testado e qual o valor de saída esperado como consequência daquelas entradas. Faz-se a comparação se o resultado obtido realmente coincide com o que era esperado, considerando os parâmetros que foram passados ao método. Além disso, casos de teste também podem ser utilizados para verificar o lançamento ou não de exceções esperadas, entre outras situações.

JUnit possui diversos métodos "assert" para fazer a comparação entre os valores esperado e obtido. Um destes métodos é o assertEquals(valorEsperado, valorObtido), que retornará true e fará o teste passar caso os valores sejam iguais. Além do assertEquals também existem diversos outros como o AssertNull, assertTrue, assertSame, assertArrayEquals, etc. Confira em http://goo.gl/2Wvqbe.

É possível também implementar um próprio método assert.

Exemplo de um caso de teste, chamado exemploTesteJUnit:

import static org.junit.Assert.*;

import org.junit.Test;

public class principalTeste {

@Test
public void CalculadoraTest(){

    Calculadora calc = new Calculadora();
    int resultado = calc.soma(4,4);
    assertEquals(8,resultado);
}

}

Após criar os testes automatizados, basta, na opção exibida pela IDE, mandar que os testes sejam rodados e será apontado então em quais testes houve aprovação e reprovação.

Conforme o código das classes vai sendo alterado com o passar do tempo, funcionalidades que já funcionavam podem acabar deixando de funcionar e rodar os testes unitários automatizados já criados anteriormente permite conferir se os métodos avaliados pelos testes continuam fazendo o que deveriam fazer conforme haviam sido aprovados antes.

Na organização do projeto, normalmente cria-se um pacote em separado para colocar as classes de teste e para cada classe a ser testada, cria-se uma classe de teste.

Dentro de uma classe de teste, cria-se um método de teste para cada método da classe original que se pretende testar. Acima de cada método de teste (os chamados casos de teste) deve haver uma anotação @Test.

Segundo processos de desenvolvimento como TDD e XP, o ideal é criar os testes unitários antes de começar o desenvolvimento e posteriormente criar o código para que se possa ser aprovado em tais testes. Tenho começado a estudar sobre TDD ultimamente e, por mais que seja um pensamento diferente do que eu costumava utilizar no desenvolvimento e cause um estranhamento inicial, tem se mostrado um bom caminho para o desenvolvimento de software que pretendo começar a seguir. Posteriormente, em alguma outra postagem, falo melhor sobre o TDD.

Na postagem a seguir falarei sobre algumas outras anotações que podem ser utilizadas no JUnit e na outra depois desta falarei sobre o uso de casos de teste para verificar o lançamento de exceções.

Até a próxima.

System.out.println("Hello World");

Olá para todos.

O objetivo deste blog é falar resumidamente de alguns assuntos que eu esteja estudando no momento sobre desenvolvimento de software, o que serviria para me ajudar a solidificar mais a informação ao escrevê-la e também para compartilhar o conhecimento.

Espero haja postagens que lhe sejam úteis e que você retorne mais vezes.

;)