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

O que é a JUnit Anotações?

JUnit Anotações é uma forma especial de metadados sintáticos que pode ser adicionada 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 em Junit4, o que torna o código Java mais readable e simples. Esta é a grande diferença entre Junit3 e Junit4 que Junit4 é baseado em anotação.

Com o conhecimento das anotações em 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 é válidowing 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:

JunitAnotaçõesExemplo.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:

  1. 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.
  1. 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.

  1. 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:

JUnit Exemplo de anotações
JUnit Exemplo de anotações

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 organização.junit.Caso de teste 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 organização.junit.Caso de teste 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 transação operaçã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 organização.junitClasse .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 organização.junit.Suíte 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
    • organização.junit.Afirmar
    • organização.junit.Caso de teste
    • organização.junit.Resultado do teste
    • organização.junit.Suíte de teste
  • Importante e frequentemente usado JUnit lista de anotações@Antes@AntesDaAula@Depois

    @Depois da aula

    @Teste

    @Ignorar