O código marcado @Beforeé executado antes de cada teste, enquanto @BeforeClassé executado uma vez antes de todo o equipamento de teste. Se sua classe de teste tiver dez testes, o @Beforecódigo será executado dez vezes, mas @BeforeClassserá executado apenas uma vez.
Em geral, você usa @BeforeClassquando vários testes precisam compartilhar o mesmo código de configuração computacionalmente caro. Estabelecer uma conexão com o banco de dados se enquadra nessa categoria. Você pode mover o código de @BeforeClasspara @Before, mas sua execução de teste pode levar mais tempo. Observe que o código marcado @BeforeClassé executado como inicializador estático, portanto, será executado antes da criação da instância de classe do seu equipamento de teste.
Na JUnit 5 , as tags @BeforeEache @BeforeAllsão equivalentes @Beforee @BeforeClassna JUnit 4. Seus nomes são um pouco mais indicativos de quando são executados, vagamente interpretados: 'antes de cada teste' e 'uma vez antes de todos os testes'.
Acrescentarei apenas que @BeforeAllpode não ser estático e chamo cada nova execução de instância de teste. Veja a resposta correspondente stackoverflow.com/a/55720750/1477873
Sergey
124
As diferenças entre cada anotação são:
+-------------------------------------------------------------------------------------------------------+¦Feature¦Junit4¦Junit5¦¦--------------------------------------------------------------------------+--------------+-------------¦¦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 anotações nas duas versões é a mesma, mas poucas diferem.
A @Beforeanotação da função será executada antes de cada uma das funções de teste da classe ter @Testanotação, mas a função com @BeforeClassserá executada apenas uma vez antes de todas as funções de teste da classe.
Da mesma forma, a função com @Afteranotação será executada após cada função de teste na classe ter @Testanotação, mas a função com @AfterClassserá executada apenas uma vez após todas as funções de teste na classe.
import org.junit.Assertimport org.junit.Beforeimport org.junit.BeforeClassimport org.junit.TestclassFeatureTest{
companion object {private lateinit var heavyFeature:HeavyFeature@BeforeClass@JvmStatic
fun beforeHeavy(){
heavyFeature =HeavyFeature()}}private lateinit var feature:Feature@Before
fun before(){
feature =Feature()}@Test
fun testCool(){Assert.assertTrue(heavyFeature.cool())Assert.assertTrue(feature.cool())}@Test
fun testWow(){Assert.assertTrue(heavyFeature.wow())Assert.assertTrue(feature.wow())}}
Igual a
import org.junit.Assertimport org.junit.TestclassFeatureTest{
companion object {private val heavyFeature =HeavyFeature()}private val feature =Feature()@Test
fun testCool(){Assert.assertTrue(heavyFeature.cool())Assert.assertTrue(feature.cool())}@Test
fun testWow(){Assert.assertTrue(heavyFeature.wow())Assert.assertTrue(feature.wow())}}
@BeforeClas
é estático. É executado antes que as instâncias da classe de teste sejam criadas.@BeforeAll
pode não ser estático e chamo cada nova execução de instância de teste. Veja a resposta correspondente stackoverflow.com/a/55720750/1477873As diferenças entre cada anotação são:
A maioria das anotações nas duas versões é a mesma, mas poucas diferem.
Referência
Ordem de execução.
Caixa tracejada -> anotação opcional.
fonte
Before e BeforeClass no JUnit
A
@Before
anotação da função será executada antes de cada uma das funções de teste da classe ter@Test
anotação, mas a função com@BeforeClass
será executada apenas uma vez antes de todas as funções de teste da classe.Da mesma forma, a função com
@After
anotação será executada após cada função de teste na classe ter@Test
anotação, mas a função com@AfterClass
será executada apenas uma vez após todas as funções de teste na classe.SampleClass
Teste de amostra
Resultado
Em 5 de junho
fonte
Igual a
fonte