junit infissi


Esempio

Da Wikipedia :

Un dispositivo di prova è usato per testare costantemente un oggetto, un dispositivo o un pezzo di software.

Può anche migliorare la leggibilità dei test estraendo codice di inizializzazione / finalizzazione comune dai metodi di test stessi.

Nei casi in cui l'inizializzazione comune può essere eseguita una volta anziché prima di ogni test, ciò può anche ridurre il tempo necessario per eseguire i test.

L'esempio seguente è ideato per mostrare le opzioni principali fornite da JUnit. Assumi una classe Foo che è costosa da inizializzare:

public class Foo {
    public Foo() {
        // expensive initialization
    }

    public void cleanUp() {
        // cleans up resources
    }
}

Un altro Bar classe ha un riferimento a Foo :

public class Bar {
    private Foo foo;
    
    public Bar(Foo foo) {
        this.foo = foo;
    }

    public void cleanUp() {
        // cleans up resources
    }
}

I test sottostanti prevedono un contesto iniziale di un elenco contenente una singola Bar .

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import java.util.List;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class FixturesTest {
    
    private static Foo referenceFoo;
    
    private List<Bar> testContext;
    
    @BeforeClass
    public static void setupOnce() {
        // Called once before any tests have run
        referenceFoo = new Foo();
    }

    @Before
    public void setup() {
        // Called before each test is run
        testContext = Arrays.asList(new Bar(referenceFoo));
    }
    
    @Test
    public void testSingle() {
        assertEquals("Wrong test context size", 1, testContext.size());
        Bar baz = testContext.get(0);
        assertEquals(referenceFoo, baz.getFoo());
    }
    
    @Test
    public void testMultiple() {
        testContext.add(new Bar(referenceFoo));
        assertEquals("Wrong test context size", 2, testContext.size());
        for (Bar baz : testContext) {
            assertEquals(referenceFoo, baz.getFoo());
        }
    }
    
    @After
    public void tearDown() {
        // Called after each test is run
        for (Bar baz : testContext) {
            baz.cleanUp();
        }
    }
    
    @AfterClass
    public void tearDownOnce() {
        // Called once after all tests have run
        referenceFoo.cleanUp();
    }
}

Nell'esempio il metodo annotato @BeforeClass setupOnce() viene utilizzato per creare l'oggetto Foo , che è costoso da inizializzare. È importante che non venga modificato da nessuno dei test, altrimenti l'esito dell'esecuzione del test potrebbe dipendere dall'ordine di esecuzione dei singoli test. L'idea è che ogni test sia indipendente e testa una piccola caratteristica.

L' setup() metodo @Before annotated setup() imposta il contesto di test. Il contesto può essere modificato durante l'esecuzione del test, motivo per cui deve essere inizializzato prima di ogni test. L'effetto equivalente potrebbe essere raggiunto includendo il codice contenuto in questo metodo all'inizio di ciascun metodo di prova.

Il metodo annotato @After tearDown() pulisce le risorse all'interno del contesto di test. Viene chiamato dopo ogni richiamo di test, e come tale viene spesso utilizzato per liberare risorse allocate in un metodo @Before annotato.

Il metodo annotato @AfterClass tearDownOnce() ripulisce le risorse una volta eseguiti tutti i test. Tali metodi vengono in genere utilizzati per liberare risorse allocate durante l'inizializzazione o in un metodo annotato @BeforeClass . Detto questo, è probabilmente meglio evitare le risorse esterne nei test unitari in modo che i test non dipendano da nulla al di fuori della classe di test.