Differenza tra setUp () e setUpBeforeClass ()

Durante il test di unità con JUnit, esistono due metodi simili setUp()e setUpBeforeClass(). Qual è la differenza tra questi metodi? Inoltre, qual è la differenza tra tearDown()e tearDownAfterClass()?

Ecco le firme:

@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 {
}

L' @BeforeClasse @AfterClassmetodi annotati verrà eseguito una sola volta durante la corsa di prova - proprio all'inizio e alla fine della prova nel suo complesso, prima di tutto viene eseguito. In effetti, vengono eseguiti prima ancora che venga costruita la classe di test, motivo per cui devono essere dichiarati static.

I metodi @Beforee @Afterverranno eseguiti prima e dopo ogni caso di test, quindi probabilmente verranno eseguiti più volte durante l'esecuzione di un test.

Quindi supponiamo che tu abbia avuto tre test nella tua classe, l'ordine delle chiamate al metodo sarebbe:

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()

Pensa a "BeforeClass" come un inizializzatore statico per il tuo caso di test - usalo per inizializzare i dati statici - cose che non cambiano nei tuoi casi di test. Devi assolutamente stare attento alle risorse statiche che non sono thread-safe.

Infine, utilizzare il metodo annotato "AfterClass" per ripulire qualsiasi impostazione eseguita nel metodo annotato "BeforeClass" (a meno che la loro autodistruzione non sia sufficiente).

"Prima" e "Dopo" sono per l'inizializzazione specifica del test unitario. In genere utilizzo questi metodi per inizializzare / reinizializzare le beffe delle mie dipendenze. Ovviamente, questa inizializzazione non è specifica per un test unitario, ma generale per tutti i test unitari.

setUpBeforeClass viene eseguito prima dell'esecuzione di qualsiasi metodo subito dopo il costruttore (eseguito una sola volta)

setUp viene eseguito prima di ogni esecuzione del metodo

tearDown viene eseguito dopo ogni esecuzione del metodo

tearDownAfterClass viene eseguito dopo tutte le altre esecuzioni del metodo, è l'ultimo metodo da eseguire. (esegui solo una volta il decostruttore)

Dal Javadoc :

A volte diversi test devono condividere un'installazione computazionalmente costosa (come l'accesso a un database). Sebbene ciò possa compromettere l'indipendenza dei test, a volte è un'ottimizzazione necessaria. L'annotazione di un public static voidmetodo no-arg con @BeforeClassfa sì che venga eseguito una volta prima di uno qualsiasi dei metodi di test nella classe. I @BeforeClassmetodi delle superclassi verranno eseguiti prima di quelli della classe corrente.