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

O que é a JUnit Anotações?

JUnit anotações são uma forma especial de metadados sintáticos que podem ser adicionados a Java O código-fonte permite melhor legibilidade e estruturação. Variáveis, parâmetros, pacotes, métodos e classes podem ser anotados. As anotações foram introduzidas em JUnit 4, o que dá 4 Java código mais legível e simples. Essa é a grande diferença entre JUnit 3 e JUnit 4: JUnit O item 4 é baseado em anotações.

Com um conhecimento prático dessas anotações, é possível aprender e implementar facilmente um JUnit teste. Abaixo estão os importantes e frequentemente usados JUnit lista de anotações, com o JUnit 5 (Júpiter) equivalente ao lado de cada um:

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 o seguinte: Java Classe que possui vários métodos associados à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 de execução de testes 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 a um, e todas as instruções de impressão poderão ser visualizadas em um console.
• Conforme discutido na tabela acima, @Before e @BeforeClass em JUnit [os métodos m2() e m1() ] serão executados antes de cada caso de teste e antes de todos os casos de teste, respectivamente.
• Da mesma forma que @After e @AfterClass em JUnit Os métodos m4() e m3() serão executados após cada caso de teste e após todos os casos de teste, respectivamente. A anotação @Ignore no método m6() será interpretada como ignorando o teste.

Vamos analisar os casos de teste usados ​​acima. Java aula em detalhes:

1. Considere o método m5() conforme apresentado abaixo:

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

No método acima, você está adicionando uma string à variável “lista”:

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

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

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

2. Considere o método m7() conforme apresentado 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) é usado para impor um tempo limite no caso de teste. O valor está em milissegundos, portanto m7() deve terminar em 10 ms.

3. Considere o método m8() conforme apresentado 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) O teste verificará a exceção especificada durante sua execução, portanto, o método m8() lançará a exceção "No Such Method Exception". Como resultado, o teste será executado com uma exceção.

Nota sobre a precisão: A função m8() apenas imprime uma linha, portanto a exceção declarada nunca é de fato lançada. JUnit O número 4 indica que o teste falhou. Alinhe o tipo esperado com o tipo que o método realmente lança. JUnit 5 escreve isso com assertThrows.

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 após o outro. Veja a captura de tela do console 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

As anotações definem quando um método é executado; os métodos de asserção definem se ele é bem-sucedido.

Esta classe fornece diversos métodos de asserção úteis na escrita de casos de teste. Se todas as asserções forem aprovadas, os resultados do teste serão bem-sucedidos. Se alguma asserção falhar, os resultados do teste serão considerados reprovados. O método dedicado JUnit afirmar O tutorial aborda cada método em detalhes.

Como você viu anteriormente, a tabela abaixo descreve os métodos Assert importantes e suas respectivas descrições:

JUnit Classe de casos de teste

Para executar vários testes, a classe TestCase está disponível no junit.framework pacote. A anotação @Test indica JUnit que este método público vazio (um caso de teste aqui) ao qual ele está anexado pode ser executado como um caso de teste.

Nota de versão: Caso de teste, Resultado do teste e Suíte de teste pertencem ao legado junit.framework pacote de JUnit 3. Eles ainda são distribuídos dentro do artefato JUnit 4.x, mas os testes baseados em anotações não estendem TestCase.

A tabela abaixo mostra alguns métodos importantes disponíveis no junit.framework.TestCase classe:

JUnit Classe TestResult

Ao executar um teste, ele retorna um resultado (na forma de um Resultado do teste objeto). Este objeto TestResult pode ser usado para analisar o objeto resultante. O resultado deste teste pode ser falha ou sucesso.

Consulte a tabela abaixo para obter informações sobre os métodos importantes usados ​​na classe junit.framework.TestResult:

JUnit Classe de conjunto de testes

Se você deseja executar vários testes em uma ordem específica, isso pode ser feito combinando todos os testes em um só lugar. Esse lugar é chamado de suíte de testes. JUnit suíte de teste O tutorial apresenta um exemplo completo.

Consulte a tabela abaixo para obter informações sobre os principais métodos utilizados no processo. junit.framework.TestSuite classe:

Perguntas Frequentes