Diferença entre @Before, @BeforeClass, @BeforeEach e @BeforeAll

Qual é a principal diferença entre

  • @BeforeClass e @BeforeClass
    • e no JUnit 5 @BeforeEach e @BeforeAll
  • @After e @AfterClass

De acordo com o JUnit Api @Before é usado no seguinte caso:

Ao escrever testes, é comum descobrir que vários testes precisam de objects semelhantes criados antes de poderem ser executados.

Considerando que @BeforeClass pode ser usado para estabelecer uma conexão de database. Mas não poderia antes fazer o mesmo?

O código marcado @Before é executado antes de cada teste, enquanto @BeforeClass é executado uma vez antes de todo o equipamento de teste. Se sua class de teste tiver dez testes, o código @BeforeClass será executado dez vezes, mas @BeforeClass será executado apenas uma vez.

Em geral, você usa @BeforeClass quando vários testes precisam compartilhar o mesmo código de configuração computacionalmente caro. Estabelecer uma conexão com o database pertence a essa categoria. Você pode mover o código de @BeforeClass para @BeforeClass , mas seu teste pode demorar mais. Observe que o código marcado @BeforeClass é executado como inicializador estático, portanto, ele será executado antes que a instância de class de seu equipamento de teste seja criada.

No JUnit 5 , as tags @BeforeEach e @BeforeAll são os equivalentes de @BeforeClass e @BeforeClass no JUnit 4. Seus nomes são um pouco mais indicativos de quando são executados, interpretados de forma imprecisa: ‘antes de cada teste’ e ‘uma vez antes de todos os testes ‘.

Diferença entre cada anotação são:

 +-------------------------------------------------------------------------------------------------------+ ¦ Feature ¦ Junit 4 ¦ Junit 5 ¦ ¦--------------------------------------------------------------------------+--------------+-------------¦ ¦ Execute before all test methods of the class are executed. ¦ @BeforeClass ¦ @BeforeAll ¦ ¦ Used with static method. ¦ ¦ ¦ ¦ For example, This method could contain some initialization code ¦ ¦ ¦ ¦-------------------------------------------------------------------------------------------------------¦ ¦ Execute after all test methods in the current class. ¦ @AfterClass ¦ @AfterAll ¦ ¦ Used with static method. ¦ ¦ ¦ ¦ For example, This method could contain some cleanup code. ¦ ¦ ¦ ¦-------------------------------------------------------------------------------------------------------¦ ¦ Execute before each test method. ¦ @Before ¦ @BeforeEach ¦ ¦ Used with non-static method. ¦ ¦ ¦ ¦ For example, to reinitialize some class attributes used by the methods. ¦ ¦ ¦ ¦-------------------------------------------------------------------------------------------------------¦ ¦ Execute after each test method. ¦ @After ¦ @AfterEach ¦ ¦ Used with non-static method. ¦ ¦ ¦ ¦ For example, to roll back database modifications. ¦ ¦ ¦ +-------------------------------------------------------------------------------------------------------+ 

A maioria das annotations em ambas as versões é a mesma, mas poucas diferem.

Referência

Ordem de Execução.

Caixa tracejada -> anotação opcional.

insira a descrição da imagem aqui

Antes e BeforeClass no JUnit

A function @Before anotação será executada antes de cada uma das funções de teste na class com anotação @Test mas a function com @BeforeClass será executada apenas uma vez antes de todas as funções de teste na class.

Similarmente, a function com anotação @After será executada após cada uma das funções de teste na class com anotação @Test mas a function com @AfterClass será executada apenas uma vez após todas as funções de teste na class.

SampleClass

 public class SampleClass { public String initializeData(){ return "Initialize"; } public String processDate(){ return "Process"; } } 

Teste de amostra

 public class SampleTest { private SampleClass sampleClass; @BeforeClass public static void beforeClassFunction(){ System.out.println("Before Class"); } @Before public void beforeFunction(){ sampleClass=new SampleClass(); System.out.println("Before Function"); } @After public void afterFunction(){ System.out.println("After Function"); } @AfterClass public static void afterClassFunction(){ System.out.println("After Class"); } @Test public void initializeTest(){ Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() ); } @Test public void processTest(){ Assert.assertEquals("Process check", "Process", sampleClass.processDate() ); } } 

Saída

 Before Class Before Function After Function Before Function After Function After Class 

Na Junit 5

 @Before = @BeforeEach @BeforeClass = @BeforeAll @After = @AfterEach @AfterClass = @AfterAll