O que são anotações JUnit?
JUNIT ANNOTATIONS é uma forma especial de metadados sintáticos que podem ser adicionados ao código-fonte Java para melhor legibilidade e estrutura do código. Variáveis, parâmetros, pacotes, métodos e classes podem ser anotados. As anotações foram introduzidas no Junit4, o que torna o código Java mais legível e simples. Esta é a grande diferença entre Junit3 e Junit4 que Junit4 é baseado em anotações.
Com o conhecimento das anotações no Junit5, pode-se aprender e implementar facilmente um teste JUnit. Abaixo está a lista de anotações importantes e usadas com frequência:
| S.No. | Anotações | Descrição |
|---|---|---|
| 1 | @Teste | Esta anotação é uma substituição de org.junit.TestCase que indica que o método void público ao qual está anexado pode ser executado como um Caso de teste. |
| 2 | @Antes | Esta anotação é usada se você quiser executar alguma instrução, como pré-condições, antes de cada caso de teste. |
| 3 | @Antes da aula | Esta anotação é usada se você deseja executar algumas instruções antes de todos os casos de teste, por exemplo, a conexão de teste deve ser executada antes de todos os casos de teste. |
| 4 | @Depois de | Esta anotação pode ser usada se você quiser executar algumas instruções após cada caso de teste para, por exemplo, redefinir variáveis, excluir arquivos temporários, variáveis, etc. |
| 5 | @Depois da aula | Esta anotação pode ser usada se você quiser executar algumas instruções após todos os casos de teste, por exemplo, Liberar recursos após a execução de todos os casos de teste. |
| 6 | @Ignores | Esta anotação pode ser usada se você quiser ignorar algumas instruções durante a execução do teste, por exemplo, desabilitar alguns casos de teste durante a execução do teste. |
| 7 | @Test (tempo limite = 500) | Esta anotação pode ser usada se você quiser definir algum tempo limite durante a execução do teste, por exemplo, se você estiver trabalhando sob algum SLA (acordo de nível de serviço), e os testes precisam ser concluídos dentro de algum tempo especificado. |
| 8 | @Test (esperado = IllegalArgumentException.class) | Esta anotação pode ser usada se você quiser lidar com alguma exceção durante a execução do teste. Por exemplo, se você deseja verificar se um método específico está lançando uma exceção especificada ou não. |
Neste tutorial, você aprenderá-
- Exemplo de anotações JUnit
- Classe JUnit Assert
- Classe de casos de teste JUnit
- Classe JUnit TestResult
- Classe JUnit Test Suite
Exemplo de anotações JUnit
Vamos criar uma classe cobrindo anotações JUnit importantes com instruções de impressão simples e executá-la com uma classe de executor de teste:
Etapa 1) Considere a classe java abaixo com vários métodos anexados às anotações listadas acima:
JunitAnnotationsExample.java
package guru99.junit;import static org.junit.Assert.assertEquals;import static org.junit.Assert.assertFalse;import java.util.ArrayList;import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Ignore;import org.junit.Test;public class JunitAnnotationsExample {lista ArrayList privada;@Antes da aulapublic static void m1 () {System.out.println ("Usando @BeforeClass, executado antes de todos os casos de teste");}@Antespublic void m2 () {list = novo ArrayList ();System.out.println ("Usando anotações @Before, executadas antes de cada caso de teste");}@Depois da aulapublic static void m3 () {System.out.println ("Usando @AfterClass, executado após todos os casos de teste");}@Depois depublic void m4 () {list.clear ();System.out.println ("Usando @After, executado após cada caso de teste");}@Testepublic void m5 () {list.add ("teste");assertFalse (list.isEmpty ());assertEquals (1, list.size ());}@Ignorarpublic void m6 () {System.out.println ("Usando @Ignore, esta execução é ignorada");}@Test (tempo limite = 10)public void m7 () {System.out.println ("Usando @Test (tempo limite), pode ser usado para impor o tempo limite no caso de teste JUnit4");}@Test (esperado = NoSuchMethodException.class)public void m8 () {System.out.println ("Usando @Test (esperado), ele verificará a exceção especificada durante sua execução");}}
Etapa 2) vamos criar uma classe de executor de teste para executar o teste acima:
TestRunner.java
package guru99.junit;import org.junit.runner.JUnitCore;import org.junit.runner.Result;import org.junit.runner.notification.Failure;public class TestRunner {public static void main (String [] args) {Resultado do resultado = JUnitCore.runClasses (JunitAnnotationsExample.class);para (falha falha: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println ("Result ==" + result.wasSuccessful ());}}
resultado esperado
- Todos os casos de teste serão executados um por um, e todas as instruções de impressão podem ser vistas em um console.
- Conforme discutido na tabela acima @Before, @BeforeClass [método m1 () e m2 ()] será executado antes de cada um e antes de todos os casos de teste, respectivamente.
- Da mesma forma @ after, @ afterClass (método m3 () e m4 ()) será executado após cada e após todos os casos de teste, respectivamente. @ignore (método m6 ()) será tratado como ignorando o teste.
Vamos analisar os casos de teste usados na classe java acima em detalhes:
- Considere o método m5 () conforme fornecido abaixo:
@Testepublic void m5 () {list.add ("teste");assertFalse (list.isEmpty ());assertEquals (1, list.size ());}
No método acima, como você está adicionando uma string na variável "lista",
- list.isEmpty () retornará falso.
- assertFalse (list.isEmpty ()) deve retornar verdadeiro.
- Como resultado, o caso de teste será aprovado .
Como você adicionou apenas uma string na lista, o tamanho é um.
- list.size () deve retornar o valor int como "1".
- Portanto, assertEquals (1, list.size ()) deve retornar verdadeiro.
- Como resultado, o caso de teste será aprovado .
- Considere o método m7 () conforme fornecido abaixo:
@Test (tempo limite = 10)public void m7 () {System.out.println ("Usando @Test (tempo limite), pode ser usado para impor o tempo limite no caso de teste JUnit4");}
Conforme discutido acima, a anotação @Test (timeout = 10) é usada para impor o tempo limite no caso de teste.
- Considere o método m8 () conforme fornecido abaixo:
@Test (esperado = NoSuchMethodException.class)public void m8 () {System.out.println ("Usando @Test (esperado), ele verificará a exceção especificada durante sua execução");}
Conforme discutido acima, @Test (esperado) verificará a exceção especificada durante sua execução, de modo que o método m8 () gerará "Nenhuma exceção de método". Como resultado, o teste será executado com uma exceção.
Como todos os casos de teste são aprovados, isso resulta em uma execução de teste bem-sucedida.
Resultado atual
Como há três casos de teste no exemplo acima, todos os casos de teste serão executados um por um. Veja a saída abaixo :
Veja abaixo as declarações de impressão que podem ser vistas no console:
Usando @BeforeClass, executado antes de todos os casos de teste
Usando anotações @Before, executadas antes de cada caso de teste
Usando @After, executado após cada caso de teste
Usando anotações @Before, executadas antes de cada caso de teste
Usando @Test (tempo limite), ele pode ser usado para impor o tempo limite no caso de teste JUnit4
Usando @After, executado após cada caso de teste
Usando anotações @Before, executadas antes de cada caso de teste
Usando @Test (esperado), ele verificará a exceção especificada durante sua execução
Usando @After, executado após cada caso de teste
Usando @AfterClass, executado após todos os casos de teste
Classe JUnit Assert
Esta classe fornece vários métodos de asserção úteis para escrever um caso de teste. Se todas as instruções assert forem aprovadas, os resultados do teste serão bem-sucedidos. Se alguma instrução assert falhar, os resultados do teste falharão.
Como você viu antes, a tabela abaixo descreve métodos e descrição importantes de Assert:
| S.No. | Método | Descrição |
|---|---|---|
| 1 | void assertEquals (booleano esperado, booleano real) | Ele verifica se dois valores são iguais ao método equals da classe Object |
| 2 | void assertFalse (condição booleana) | funcionalidade é verificar se uma condição é falsa. |
| 3 | void assertNotNull (objeto Object) | A funcionalidade "assertNotNull" serve para verificar se um objeto não é nulo. |
| 4 | void assertNull (objeto Object) | A funcionalidade "assertNull" serve para verificar se um objeto é nulo. |
| 5 | void assertTrue (condição booleana) | A funcionalidade "assertTrue" serve para verificar se uma condição é verdadeira. |
| 6 | void fail () | Se você quiser lançar qualquer erro de asserção, você tem fail () que sempre resulta em um veredicto de falha. |
| 7 | void assertSame ([String mensagem] | A funcionalidade "assertSame" serve para verificar se os dois objetos se referem ao mesmo objeto. |
| 8 | void assertNotSame ([String mensagem] | A funcionalidade "assertNotSame" serve para verificar se os dois objetos não se referem ao mesmo objeto. |
Classe de casos de teste JUnit
Para executar vários testes, a classe TestCase está disponível nos pacotes org.junit.TestCase . A anotação @Test diz ao JUnit que este método void público (caso de teste aqui) ao qual está anexado pode ser executado como um caso de teste.
A tabela abaixo mostra alguns métodos importantes disponíveis na classe org.junit.TestCase :
| S.No. | Método | Descrição |
|---|---|---|
| 1 | int countTestCases () | Este método é usado para contar quantos casos de teste executados pelo método run (TestResult tr) . |
| 2 | TestResult createResult () | Este método é usado para criar um objeto TestResult . |
| 3 | String getName () | Este método retorna uma string que nada mais é do que um TestCase . |
| 4 | TestResult run () | Este método é usado para executar um teste que retorna um objeto TestResult |
| 5 | void run (resultado do TestResult) | Este método é usado para executar um teste com um objeto TestResult que não retorna nada. |
| 6 | void setName (nome da string) | Este método é usado para definir o nome de um TestCase. |
| 7 | void setUp () | Este método é usado para escrever código de associação de recursos. por exemplo, crie uma conexão de banco de dados. |
| 8 | void tearDown () | Este método é usado para escrever código de liberação de recurso. por exemplo, libere a conexão do banco de dados após realizar a operação de transação. |
Classe JUnit TestResult
Quando você executa um teste, ele retorna um resultado (na forma de objeto TestResult ). Este objeto TestResult pode ser usado para analisar o objeto resultante. O resultado do teste pode ser falha ou bem-sucedido. Veja a tabela abaixo para métodos importantes usados na classe org.junit.TestResult:| S.No. | Método | Descrição |
|---|---|---|
| 1 | void addError (teste de teste, t Throwable) | Este método é usado se você precisar adicionar um erro ao teste. |
| 2 | void addFailure (teste de teste, AssertionFailedError t) | Este método é usado se você precisar adicionar uma falha à lista de falhas. |
| 3 | void endTest (teste de teste) | Este método é usado para notificar que um teste é realizado (concluído) |
| 4 | int errorCount () | Este método é usado para obter o erro detectado durante a execução do teste. |
| 5 | Erros de enumeração | Este método simplesmente retorna uma coleção (Enumeração aqui) de erros. |
| 6 | int failureCount () | Este método é usado para obter a contagem de erros detectados durante a execução do teste. |
| 7 | void run (teste TestCase) | Este método é usado para executar um caso de teste. |
| 8 | int runCount () | Este método simplesmente conta o teste executado. |
| 9 | void startTest (teste de teste) | Este método é usado para notificar que um teste foi iniciado. |
| 10 | void stop () | Este método é usado para testar a execução a ser interrompida. |
Classe JUnit Test Suite
Se você deseja executar vários testes em uma ordem especificada, pode ser feito combinando todos os testes em um só lugar. Este local é chamado de suítes de teste.
Veja a tabela abaixo para métodos importantes usados na classe org.junit.TestSuite :
| S.No. | Método | Descrição |
|---|---|---|
| 1 | void addTest (teste de teste) | Este método é usado se você deseja adicionar um teste ao conjunto. |
| 2 | void addTestSuite (Class testClass) | Este método é usado se você deseja especificar a classe ao adicionar um teste ao conjunto. |
| 3 | int countTestCases () | Este método é usado se você deseja contar o número de casos de teste. |
| 4 | String getName () | Este método é usado para obter o nome do conjunto de testes. |
| 5 | void run (resultado do TestResult) | Este método é usado para executar um teste e coletar o resultado do teste no objeto TestResult . |
| 6 | void setName (nome da string) | Este método é usado para definir o nome do TestSuite . |
| 7 | Teste testAt (índice interno) | Este método é usado se você deseja retornar o teste em um determinado índice. |
| 8 | int testCount () | Este método é usado se você deseja retornar uma série de testes no Suite. |
| 9 | Aviso de teste estático (mensagem de string) | Este método retorna um teste que falhará e registrará uma mensagem de aviso. |
Resumo:
- JUnit fornece uma API portátil, que fornece todas as classes e anotações importantes úteis para escrever um teste de unidade.
- Aulas que são muito úteis ao escrever um caso de teste
- org.junit.Assert
- org.junit.TestCase
- org.junit.TestResult
- org.junit.TestSuite
- lista de anotações importantes e freqüentemente usadas
@Antes
@Antes da aula
@Depois de
@Depois da aula
@Teste
@Ignorar