JUnit Tutorial de anotações com exemplo: O que é @Test e @After

O que é o JUnit Anotações?

JUnit Anotações é uma forma especial de metadados sintáticos que podem ser adicionados a Java código fonte para melhor legibilidade e estrutura do código. Variáveis, parâmetros, pacotes, métodos e classes podem ser anotados. Anotações foram introduzidas no Junit4, o que torna Java código mais legível e simples. Essa é a grande diferença entre Junit3 e Junit4, que Junit4 é baseado em anotações.

Com o conhecimento das anotações no Junit5, pode-se facilmente aprender e implementar um JUnit teste. Abaixo estão os importantes e frequentemente usados JUnit lista de anotações:

S.No.	Anotações	Descrição
1.	@Teste	Esta anotação é uma substituição de org.junit.TestCase que indica que o método public void ao qual está anexado pode ser executado como um caso de teste.
2.	@Antes	Esta anotação é usada se você deseja 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 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 executar todos os casos de teste.
6.	@Ignora	Esta anotação pode ser usada se você quiser ignorar algumas instruções durante a execução do teste, por exemplo, desabilitando alguns casos de teste durante a execução do teste.
7.	@Teste(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 precisarem ser concluídos dentro de um tempo especificado.
8.	@Test(esperado=IllegalArgumentException.class)	Esta anotação pode ser usada se você quiser tratar 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.

JUnit Exemplo de anotações

Vamos criar uma classe cobrindo importantes JUnit anotações com instruções de impressão simples e execute-as com uma classe de executor de teste:

Passo 1) Considere a classe Java abaixo com vários métodos anexados às anotações listadas acima:

Exemplo de anotações Junit.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 {				

    private ArrayList<String> list;					

    @BeforeClass		
    public static void m1() {							
        System.out.println("Using @BeforeClass , executed before all test cases ");					
    }		

    @Before		
    public void m2() {					
        list = new ArrayList<String>();					
        System.out.println("Using @Before annotations ,executed before each test cases ");					
    }		

    @AfterClass		
    public static void m3() {							
        System.out.println("Using @AfterClass ,executed after all test cases");					
    }		

    @After		
    public void m4() {					
        list.clear();			
        System.out.println("Using @After ,executed after each test cases");					
    }		

    @Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

    @Ignore		
    public void m6() {					
        System.out.println("Using @Ignore , this execution is ignored");					
    }		

    @Test(timeout = 10)			
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

    @Test(expected = NoSuchMethodException.class)					
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					

    }		

}

Passo 2) vamos criar uma classe 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) {									
      Result result = JUnitCore.runClasses(JunitAnnotationsExample.class);					
			for (Failure failure : 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 anotação em JUnit, @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 em JUnit, @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 detalhadamente os casos de teste usados na classe Java acima:

Considere o método m5() conforme fornecido abaixo:

	@Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }

No método acima, como você está adicionando uma string na variável “lista”, então

lista.isEmpty() retornará falso.
assertFalse(list.isEmpty()) deve retornar verdadeiro.
Como resultado, o caso de teste passar.

Como você adicionou apenas uma string na lista, o tamanho é um.

lista.tamanho() deve retornar o valor int como “1”.
So assertEquals(1, list.size()) deve retornar verdadeiro.
Como resultado, o caso de teste passar.

Considere o método m7() conforme fornecido abaixo:

@Test(timeout = 10)		
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }

Como discutido acima @Teste(tempo limite = 10)a anotação é usada para impor o tempo limite no caso de teste.

Considere o método m8() conforme fornecido abaixo:

@Test(expected = NoSuchMethodException.class)				
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					
    
    }

Como discutido acima @Teste(esperado) verificará a exceção especificada durante sua execução, então o método m8() lançará “No Such Method Exception”. 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 existem 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 instruçõ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(timeout), pode ser usado para impor o tempo limite em JUnit4 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(expected) , 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

JUnit Afirmar classe

Esta classe fornece vários métodos de asserção úteis na escrita de 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 anteriormente, a tabela abaixo descreve métodos e descrições importantes de Assert:

S.No.	Forma	Descrição
1.	void assertEquals(booleano esperado, booleano real)	Ele verifica se dois valores são iguais semelhantes ao método equals da classe Object
2.	void assertFalse (condição booleana)	funcionalidade é verificar se uma condição é falsa.
3.	void assertNotNull (objeto objeto)	A funcionalidade “assertNotNull” serve para verificar se um objeto não é nulo.
4.	void assertNull (objeto objeto)	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.	falha nula()	Se quiser gerar algum erro de afirmaçã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.

JUnit Classe de casos de teste

Para executar vários testes, a classe TestCase está disponível em org.junit.CasoDeTeste pacotes. A anotação @Test informa JUnit que este método public void (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 em org.junit.CasoDeTeste classe:

S.No.	Forma	Descrição
1.	int contagemTestCases()	Este método é usado para contar quantos casos de teste foram executados por executar (TestResult tr) método.
2.	ResultadoTeste createResult()	Este método é usado para criar um Resultado do teste objeto.
3.	String getName ()	Este método retorna uma string que nada mais é do que um Caso de teste.
4.	Execução do resultado do teste()	Este método é usado para executar um teste que retorna um Resultado do teste objeto
5.	execução nula (resultado TestResult)	Este método é usado para executar um teste com um Resultado do teste objeto que não retorna nada.
6.	void setName (nome da string)	Este método é usado para definir o nome de um Caso de teste.
7.	configuração vazia()	Este método é usado para escrever código de associação de recursos. por exemplo, crie uma conexão de banco de dados.
8.	vazio tearDown()	Este método é usado para escrever código de liberação de recursos. por exemplo, liberar conexão com o banco de dados após realizar a operação de transação.

JUnit Classe TestResult

Quando você executa um teste, ele retorna um resultado (na forma de Resultado do teste objeto). Este objeto TestResult pode ser usado para analisar o objeto resultante. Este resultado de teste pode ser uma falha ou um sucesso.

Veja a tabela abaixo para métodos importantes usados na classe org.junit.TestResult:

S.No.	Forma	Descrição
1.	void addError(Teste de teste, Throwable t)	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 foi realizado (concluído)
4.	contagem de erros int()	Este método é usado para obter o erro detectado durante a execução do teste.
5.	Enumeração erros()	Este método simplesmente retorna uma coleção (enumeração aqui) de erros.
6.	int falhaCount()	Este método é usado para obter a contagem de erros detectados durante a execução do teste.
7.	execução nula (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.	parada nula()	Este método é usado para testar a execução a ser interrompida.

JUnit Classe de conjunto de testes

Se você deseja executar vários testes em uma ordem especificada, isso pode ser feito combinando todos os testes em um só lugar. Este lugar é chamado de suítes de teste.

Veja a tabela abaixo para métodos importantes usados em org.junit.Suite de Teste classe:

S.No.	Forma	Descrição
1.	void addTest (teste de teste)	Este método é usado se você deseja adicionar um teste ao conjunto.
2.	void addTestSuite(Classe classe de teste)	Este método é usado se você deseja especificar a classe ao adicionar um teste ao conjunto.
3.	int contagemTestCases()	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.	execução nula (resultado TestResult)	Este método é usado para executar um teste e coletar o resultado do teste em Resultado do teste objeto.
6.	void setName (nome da string)	Este método é usado para definir o nome de Suíte de teste.
7.	Teste testAt(índice int)	Este método é usado se você deseja retornar o teste em determinado índice.
8.	int testCount()	Este método é usado se você deseja retornar vários 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 funções importantes Selenium anotações úteis ao escrever um teste de unidade.
Classes que são muito úteis ao escrever um caso de teste
- org.junit.Assert
- org.junit.CasoDeTeste
- org.junit.ResultadoTeste
- org.junit.Suite de Teste
Importante e frequentemente usado JUnit lista de anotações@Antes@AntesDaAula@Depois
@Depois da aula

@Teste

@Ignorar

Você pode gostar:

O que é o JUnit Anotações?

JUnit Exemplo de anotações

Exemplo de anotações Junit.java

TestRunner.java

resultado esperado

Resultado atual

ARTIGOS RELACIONADOS

JUnit Afirmar classe

JUnit Classe de casos de teste

JUnit Classe TestResult

JUnit Classe de conjunto de testes

Resumo