Diferença entre setUp () e setUpBeforeClass ()

Ao testar a unidade com JUnit, existem dois métodos semelhantes, setUp()e setUpBeforeClass(). Qual é a diferença entre esses métodos? Além disso, qual é a diferença entre tearDown()e tearDownAfterClass()?

Aqui estão as assinaturas:

@BeforeClass
public static void setUpBeforeClass() throws Exception {
}

@AfterClass
public static void tearDownAfterClass() throws Exception {
}

@Before
public void setUp() throws Exception {
}

@After
public void tearDown() throws Exception {
}

Os métodos anotado @BeforeClasse @AfterClassserão executados exatamente uma vez durante a execução do teste - no início e no final do teste como um todo, antes que qualquer outra coisa seja executada. Na verdade, eles são executados antes que a classe de teste seja construída, e é por isso que devem ser declarados static.

Os métodos @Beforee @Afterserão executados antes e depois de cada caso de teste, portanto, provavelmente serão executados várias vezes durante uma execução de teste.

Então, vamos supor que você tenha três testes em sua classe, a ordem das chamadas de método seria:

setUpBeforeClass()

  (Test class first instance constructed and the following methods called on it)
    setUp()
    test1()
    tearDown()

  (Test class second instance constructed and the following methods called on it)
    setUp()
    test2()
    tearDown()

  (Test class third instance constructed and the following methods called on it)
    setUp()
    test3()
    tearDown()

tearDownAfterClass()

Pense em "BeforeClass" como um inicializador estático para seu caso de teste - use-o para inicializar dados estáticos - coisas que não mudam nos casos de teste. Você definitivamente deseja ter cuidado com os recursos estáticos que não são seguros para threads.

Por fim, use o método anotado "AfterClass" para limpar qualquer configuração feita no método anotado "BeforeClass" (a menos que a autodestruição seja boa o suficiente).

"Antes" e "Depois" são para inicialização específica do teste de unidade. Normalmente, uso esses métodos para inicializar / reinicializar as zombarias das minhas dependências. Obviamente, essa inicialização não é específica para um teste de unidade, mas geral para todos os testes de unidade.

setUpBeforeClass é executado antes de qualquer execução de método logo após o construtor (executado apenas uma vez)

setUp é executado antes de cada execução do método

tearDown é executado após cada execução de método

tearDownAfterClass é executado após todas as outras execuções de método, é o último método a ser executado. (execute apenas uma vez desconstrutor)

Do Javadoc :

Às vezes, vários testes precisam compartilhar configurações computacionalmente caras (como fazer login em um banco de dados). Embora isso possa comprometer a independência dos testes, às vezes é uma otimização necessária. Anotar um public static voidmétodo no-arg com @BeforeClassfaz com que ele seja executado uma vez antes de qualquer método de teste na classe. Os @BeforeClassmétodos das superclasses serão executados antes dos da classe atual.