Como usar as anotações @Before e @After no JUnit

Quando você está escrevendo um conjunto de testes de unidade, pode haver algumas atividades não relacionadas a testes que você precisa realizar. Essas atividades podem assumir qualquer forma. Talvez você precise se conectar a um banco de dados ou reunir recursos antes de realizar um teste. Após a execução de cada caso de teste, talvez seja necessário liberar alguns recursos.

exceção do windows 10 kmode não tratada

MAKEUSEO VÍDEO DO DIA

A execução de qualquer uma dessas atividades não relacionadas a testes fora do escopo de uma classe de teste de unidade pode ser tediosa, se não impossível. A execução bem-sucedida de sua classe de teste pode depender dessas atividades, portanto, o JUnit fornece dois pares de anotações para resolver esse problema.

---

---

A anotação @BeforeAll

Uma classe de teste JUnit pode ter um ou mais métodos de teste. A anotação @BeforeAll sinaliza que um método específico deve ser executado antes de todos os métodos de teste em uma classe de teste. O método associado a esta anotação é executado apenas uma vez (no início do teste), independentemente do número de métodos de teste na classe de teste.

Qualquer método que use a anotação @BeforeAll deve seguir algumas estipulações. Esses métodos devem ter um tipo de retorno void, devem ser públicos e não devem ser privados. A anotação @BeforeAll é ideal para estabelecer um conexão com um banco de dados ou criando um novo arquivo. Este artigo usa uma classe de teste de calculadora para mostrar como você pode usar a anotação @BeforeAll.

A classe da calculadora

package com.app; 
public class Calculator { 
      public static int add(int num1, int num2) { 
             return num1 + num2; 
      } 
      public static int subtract(int num1, int num2) { 
             return num1 - num2; 
      } 
      public static int multiply(int num1, int num2) { 
             return num1 * num2; 
      } 
      public static int divide(int num1, int num2) { 
             return num1 / num2; 
      } 
}

A classe de teste Calculator

import static org.junit.jupiter.api.Assertions.*; 
import org.junit.jupiter.api.BeforeAll; 
import org.junit.jupiter.api.Test; 
import org.junit.jupiter.api.DisplayName; 
  
@DisplayName("Test class demonstrating how to use the before and after annotations.") 
class CalculatorTest { 
      @BeforeAll 
      public static void powerOnCalculator() { 
             System.out.println("The calculator is on"); 
      } 
  
      @Test 
      @DisplayName("Testing method that adds two integer values.") 
      public void testAdd() { 
             assertEquals(7, Calculator.add(3, 4)); 
      }      
  
      @Test 
      @DisplayName("Testing method that subtracts one integer value from another.") 
      public void testSubtract() { 
             assertEquals(6, Calculator.subtract(9, 3)); 
      } 
  
      @Test 
      @DisplayName("Testing method that multiplies two integer values") 
      public void testMultiply() { 
             assertEquals(10, Calculator.multiply(5, 2)); 
      } 
  
      @Test 
      @DisplayName("Testing method that divides one integer value by another") 
      public void testDivide() { 
             assertEquals(2, Calculator.divide(4, 2)); 
      } 
}

Nesta classe, a anotação @BeforeAll funciona com o método powerOnCalculator(), que imprime “A calculadora está ligada” antes de qualquer execução de teste. A execução do teste bem-sucedida imprime o seguinte relatório de teste:

Como você pode ver, o método associado à anotação @BeforeAll não aparece no relatório de teste. No entanto, se houver um erro no método de anotação @BeforeAll, os resultados do relatório de teste indicarão isso com uma falha.

A anotação @BeforeEach

Assim como o método anotado @BeforeAll, o método anotado @BeforeEach não aparecerá no relatório de teste. O método anotado @BeforeEach é executado antes de cada método de teste em uma classe de teste. Portanto, se uma classe de teste contiver dois métodos de teste, a anotação @BeforeEach será executada duas vezes.

---

---

o disco rígido não inicializa o Windows 10

import static org.junit.jupiter.api.Assertions.*; 
import org.junit.jupiter.api.BeforeAll; 
import org.junit.jupiter.api.BeforeEach; 
import org.junit.jupiter.api.Test; 
@DisplayName("Test class demonstrating how to use the before and after annotations.") 
class CalculatorTest { 
      @BeforeAll 
      public static void powerOnCalculator() { 
             System.out.println("The calculator is on"); 
      } 
      @BeforeEach 
      public void clearCalculator() { 
             System.out.println("The calculator is ready"); 
      } 
      @Test 
      @DisplayName("Testing method that adds two integer values.") 
      public void testAdd() { 
             assertEquals(7, Calculator.add(3, 4)); 
      }      
      @Test 
      @DisplayName("Testing method that subtracts one integer value from another.") 
      public void testSubtract() { 
             assertEquals(6, Calculator.subtract(9, 3)); 
      } 
      @Test 
      @DisplayName("Testing method that multiplies two integer values") 
      public void testMultiply() { 
             assertEquals(10, Calculator.multiply(5, 2)); 
      } 
      @Test 
      @DisplayName("Testing method that divides one integer value by another") 
      public void testDivide() { 
             assertEquals(2, Calculator.divide(4, 2)); 
      } 
} 

Adicionar a anotação @BeforeEach à classe CalculatorTest produz a seguinte saída:

O método associado à anotação @BeforeEach é executado quatro vezes, uma vez antes de cada método de teste. Você deve observar que o método @BeforeEach não é estático, tem um tipo de retorno void e não é privado, pois são estipulações obrigatórias. Também é importante observar que o método associado à anotação @BeforeEach é executado após o método @BeforeAll.

---

---

A anotação @AfterAll

Um método com a anotação @AfterAll será executado depois que todos os métodos de teste na classe de teste concluírem sua execução. A anotação @AfterAll é ideal para operações básicas de arquivo , como fechar um arquivo ou desconectar-se de um banco de dados. A anotação @AfterAll é a contrapartida da anotação @BeforeAll. Assim como a anotação @BeforeAll, a anotação @AfterAll deve ser estática, deve retornar void e não ser privada.

@AfterAll 
public static void powerOffCalculator() { 
    System.out.println("The calculator is off"); 
}

Adicionar o método anotado @AfterAll à classe CalculatorTest existente imprime a seguinte saída no console:

Observe que o método powerOffCalculator(), que usa a anotação @AfterAll, é impresso no final da classe de teste, após a execução de todos os métodos de teste.

A anotação @AfterEach

A anotação @AfterEach é a contrapartida da anotação @BeforeEach. Eles têm as mesmas estipulações obrigatórias, que são ligeiramente diferentes das anotações @BeforeAll e @AfterAll. O que distingue a anotação @AfterEach da anotação @BeforeEach (além de seus nomes) é que o método @AfterEach é executado após cada método de teste.

como fazer o instalador usb do windows 10

@AfterEach 
public void returnResults() { 
    System.out.println("The results are ready"); 
}

A execução da classe CalculatorTest imprime a seguinte saída no console:

A saída mostra que o método associado à anotação @AfterEach (returnResults) é impresso quatro vezes. Cada execução do método returnResults() só acontece após a execução de cada teste unitário. Isso é evidente pelo fato de que a saída do método returnResults() aparece após cada saída do método associado à anotação @BeforeEach.

Aprimore seus conjuntos de testes usando anotações

JUnit permite que você lide com processos não relacionados a testes usando as anotações de par antes e depois. Essas quatro anotações pertencem a uma lista de várias outras anotações que agregam valor aos seus testes. Outra das anotações do JUnit é @DisplayName.

Os dois exemplos de código que exibem a classe CalculatorTest completa usam a anotação @DisplayName. A anotação @DisplayName ajuda você a criar nomes mais significativos para suas classes de teste e métodos de teste.