Eu achei o uso adequado (ou pelo menos a documentação) do JUnit muito confuso. Essa pergunta serve como referência futura e como uma pergunta real.
Se eu entendi corretamente, há duas abordagens principais para criar e executar um teste JUnit:
Abordagem A (JUnit 3-estilo): criar uma classe que se estende TestCase, e comece a métodos de ensaio com a palavra test
. Ao executar a classe como um Teste JUnit (no Eclipse), todos os métodos iniciados com a palavra test
são executados automaticamente.
import junit.framework.TestCase;
public class DummyTestA extends TestCase {
public void testSum() {
int a = 5;
int b = 10;
int result = a + b;
assertEquals(15, result);
}
}
Abordagem B (estilo JUnit 4): crie uma classe 'normal' e adicione uma @Test
anotação ao método. Note que você não tem que começar o método com a palavra test
.
import org.junit.*;
import static org.junit.Assert.*;
public class DummyTestB {
@Test
public void Sum() {
int a = 5;
int b = 10;
int result = a + b;
assertEquals(15, result);
}
}
Misturar os dois parece não ser uma boa ideia, veja, por exemplo, esta pergunta sobre o stackoverflow :
Agora, minhas perguntas:
- Qual é a abordagem preferida ou quando você usaria uma em vez da outra?
- A abordagem B permite testar exceções estendendo a anotação @Test como em
@Test(expected = ArithmeticException.class)
. Mas como você testa exceções ao usar a abordagem A? Ao usar a abordagem A, você pode agrupar várias classes de teste em um conjunto de testes como este:
TestSuite suite = new TestSuite("All tests");
suite.addTestSuite(DummyTestA.class);
suite.addTestSuite(DummyTestAbis.class);
Mas isso não pode ser usado com a abordagem B (uma vez que cada classe de teste deve subclassificar TestCase). Qual é a maneira correta de agrupar testes para a abordagem B?
Editar: adicionei as versões do JUnit às duas abordagens
fonte
extends TestCase
e, em seguida, cada teste também anotou@Test
apenas para confundir as coisas. :)Respostas:
A distinção é bastante fácil:
TestCase
é a maneira como os testes de unidade foram escritos no JUnit 3 (é claro que ainda é suportado no JUnit 4)@Test
anotação é a maneira apresentada pelo JUnit 4Geralmente, você deve escolher o caminho da anotação, a menos que seja necessária compatibilidade com o JUnit 3 (e / ou uma versão Java anterior ao Java 5). A nova maneira tem várias vantagens:
@Test
anotação é mais explícita e é mais fácil de suportar em ferramentas (por exemplo, é fácil procurar todos os testes dessa maneira)@Before
/@BeforeClass
e@After
/@AfterClass
proporcionando mais flexibilidade@Rule
anotações sobre coisas comoExpectedException
@Ignored
anotação@RunWith
Para testar as exceções esperadas em uma JUnit 3,
TestCase
é necessário tornar o texto explícito.O JUnit 5 introduziu mais uma alteração na API, mas ainda usa anotações. A nova
@Test
anotação éorg.junit.jupiter.api.Test
(a "antiga" JUnit 4 eraorg.junit.Test
), mas funciona praticamente da mesma forma que a JUnit 4.fonte
assertTrue(e.getMessage().contains("foo"))
pode ser útil.expected
método verifica apenas o tipo.Eu tenho uma preferência pelo JUnit 4 (abordagem de anotação) porque acho mais flexível.
Se você deseja construir o conjunto de testes no JUnit 4, é necessário criar uma classe agrupando todos os testes como este:
fonte
Há uma parte não respondida em sua pergunta, e é "Qual é a maneira correta de agrupar testes para a abordagem B?"
A resposta oficial é que você anota uma classe com um @RunWith (Suite.class) e, em seguida, usa a anotação @ Suite.SuiteClasses para listar as classes. É assim que os desenvolvedores do JUnit o fazem (listando todas as classes em um conjunto manualmente). De muitas maneiras, essa abordagem é uma melhoria, pois é trivial e intuitivo adicionar comportamentos antes e depois do conjunto (basta adicionar os métodos @BeforeClass e @AfterClass à classe anotada com o @RunWith - muito melhor que o antigo TestFixture )
No entanto, há um retrocesso, pois as anotações não permitem criar dinamicamente a lista de classes, e contornar esse problema fica um pouco feio. Você precisa subclassificar a classe Suite e criar dinamicamente a matriz de classes na subclasse e passá-la ao construtor Suite, mas essa é uma solução incompleta, pois outras subclasses da Suite (como Categorias) não funcionam com ela e essencialmente não suporta coleção de classes de teste dinâmica.
fonte
Você deve usar o JUnit 4. É melhor.
Muitas estruturas começaram a descontinuar o suporte ao JUnit 3.8.
Isto é da documentação de referência do Spring 3.0:
Em geral, você deve sempre tentar usar a versão estável mais recente de uma estrutura ao iniciar algo novo.
fonte
A abordagem "preferida" seria usar anotações que foram introduzidas desde o dia 4 de junho. Elas facilitam muitas coisas (veja sua segunda pergunta)
Você pode usar um bloco try / catch simples para isso:
fonte