Apesar de não ser um assunto novo, motivado pelos projetos em que trabalhei ainda utilizarem a versão 3.x do JUnit, essa semana decidi ver quais são as principais diferenças entre o JUnit 3.x e o 4.x.


Conversando com amigos, Gandra, Luiz e Miudo, eles me disseram: “A principal diferença é que no JUnit 4.x usamos anotações, nada além disso…” fiquei intrigado e fui atrás…Para compartilhar minha pesquisa, abaixo seguem as principais diferenças:


1. @Test: Você não precisa mais que seus métodos de teste iniciem com o prefixo “test”, eles devem possuir a anotação “@Test”, Além disso você não precisa mais estender a classe “TestCase”, conforme segue o exemplo abaixo:

@Test
public void addition() {
     assertEquals(12, simpleMath.add(7, 5));
}


2. @Before e @After: Respectivamente, essas anotações subistituem os métodos “setup” e “tearDown”, são utilizadas para executar procedimentos antes e depois de cada um dos testes, conforme segue o exemplo abaixo:

@Before
public void runBeforeEveryTest() {
     simpleMath = new SimpleMath();
}

@After
public void runAfterEveryTest() {
     simpleMath = null;
}


3. @BeforeClass e @AfterClass: Essas anotações substituem o “setup” e “tearDown” porém são executadas só uma vez, essa sim é uma feature nova, não tinhamos nada parecido nas versões anteriores, porém só vi grande utilidade no caso de usarmos suite, abaixo segue um exemplo:

@BeforeClass
public static void runBeforeClass() {
     // run for one time before all test cases
}

@AfterClass
public static void runAfterClass() {
     // run for one time after all test cases
}


4. Exceções esperadas: Para testarmos a cobertura do fluxo e tratamento de exceções esperadas, usamos o atributo “expected” na anotação @Test, abaixo segue um exemplo onde claramente vemos isso.

@Test(expected = ArithmeticException.class)
public void divisionWithException() {
     // divide by zero
     simpleMath.divide(1, 0);
}


5. @Ignore: Esta anotação indica que o teste será ignorado, ou seja, não será executado. Você pode adicionar um parâmetro à esta anotação o qual indica o motivo deste teste ser ignorado. Muito legal para deixar de forma clara que o teste não será executado, conforme segue o exemplo abaixo:

@Ignore("Not ready to run")
@Test
public void multiplication() {
     assertEquals(15, simpleMath.multiply(3, 5));
}


6. Timeout: Podemos também definir um tempo máximo onde o teste deve ser executado, para isso, basta incluirmos atributo timeout, esse em milissegundos. O teste falhará se o tempo de execussão dele ultrapassar o timeout definido, conforme exemplo abaixo:

@Test(timeout = 1000)
public void infinity() {
     while (true);
}


7. Novas Assertions: Novos métodos para comparação de arrays, dois arrays são considerados iguais se seus tamanhos forem iguais e também se o valor correspondente a cada um de seus elementos também for igual, caso contrario não são considerados iguais, conforme exemplo abaixo:

@Test
public void listEquality() {
     List expected = new ArrayList();
     expected.add(5);
     List actual = new ArrayList();
     actual.add(5);
     assertEquals(expected, actual);
}


Como disse no início essas são apenas as principais mudanças no JUnit 4.x, existem outras, em meu ponto de vista menos importantes e por isso não as descreverei.Depois de tudo isso a conclusão que eu cheguei foi que infelizmente eles estavam certos… Se eu fosse iniciar um novo projeto já começaria com a versão 4.x, más não identifiquei nenhuma feature ou melhoria que motivasse a migração da versão 3.x para a 4.x.


Referências:

http://www.junit.org/

http://www-128.ibm.com/developerworks/java/library/j-junit4.html

http://www.cavdar.net/2008/07/21/junit-4-in-60-seconds/