Espresso Testing Framework - Panoramica di JUnit

In questo capitolo, cerchiamo di comprendere le basi di JUnit , il popolare framework di unit test sviluppato dalla comunità Java su cui è costruito il framework di test espresso.

JUnit è lo standard de facto per il test unitario di un'applicazione Java. Anche se è popolare per i test di unità, ha il supporto completo e la fornitura anche per i test di strumentazione. La libreria di test Espresso estende le classi JUnit necessarie per supportare i test di strumentazione basati su Android.

Scrivi un semplice test unitario

Creiamo una classe Java, Computation (Computation.java) e scriviamo semplici operazioni matematiche, Somma e Moltiplicazione . Quindi, scriveremo i casi di test utilizzando JUnit e lo controlleremo eseguendo i casi di test.

Avvia Android Studio.
Apri HelloWorldApp creata nel capitolo precedente.
Crea un file, Computation.java in app / src / main / java / com / tutorialspoint / espressosamples / helloworldapp / e scrivi due funzioni: Somma e Moltiplica come specificato di seguito,

package com.tutorialspoint.espressosamples.helloworldapp;
public class Computation {
   public Computation() {}
   public int Sum(int a, int b) {
      return a + b;
   }
   public int Multiply(int a, int b) {
      return a * b;
   }
}

Crea un file, ComputationUnitTest.java in app / src / test / java / com / tutorialspoint / espressosamples / helloworldapp e scrivi casi di unit test per testare la funzionalità Somma e Moltiplica come specificato di seguito

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class ComputationUnitTest {
   @Test
   public void sum_isCorrect() {
      Computation computation = new Computation();
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      Computation computation = new Computation();
      assertEquals(4, computation.Multiply(2,2));
   }
}

Qui abbiamo usato due nuovi termini: @Test e assertEquals . In generale, JUnit utilizza l'annotazione Java per identificare i casi di test in una classe e le informazioni su come eseguire i casi di test. @Test è una di queste annotazioni Java, che specifica che la particolare funzione è un test case junit. assertEquals è una funzione per affermare che il primo argomento (valore atteso) e il secondo argomento (valore calcolato) sono uguali e uguali. JUnit fornisce una serie di metodi di asserzione per diversi scenari di test.

Ora, esegui ComputationUnitTest nello studio Android facendo clic con il pulsante destro del mouse sulla classe e invocando l' opzione Esegui "ComputationUnitTest" come spiegato nel capitolo precedente. Questo eseguirà i casi di unit test e segnalerà il successo.

Il risultato dello unit test di calcolo è come mostrato di seguito:

Annotazioni

Il framework JUnit utilizza ampiamente l'annotazione . Alcune delle annotazioni importanti sono le seguenti:

@Test
@Before
@After
@BeforeClass
@AfterClass
@Rule

@ Annotazione di prova

@Test è l'annotazione molto importante nel framework JUnit . @Test viene utilizzato per differenziare un metodo normale dal metodo del caso di test. Una volta che un metodo è decorato con l' annotazione @Test , quel particolare metodo viene considerato come un test case e verrà eseguito da JUnit Runner . JUnit Runner è una classe speciale, che viene utilizzata per trovare ed eseguire i casi di test JUnit disponibili all'interno delle classi java. Per ora, stiamo utilizzando l' opzione build in di Android Studio per eseguire gli unit test (che a loro volta eseguono JUnit Runner ). Un codice di esempio è il seguente,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   @Test
   public void multiply_isCorrect() {
      Computation computation = new Computation();
      assertEquals(4, computation.Multiply(2,2));
   }
}

@Prima

L' annotazione @Before viene utilizzata per fare riferimento a un metodo, che deve essere richiamato prima di eseguire qualsiasi metodo di test disponibile in una particolare classe di test. Ad esempio, nel nostro esempio, l' oggetto Computation può essere creato in un metodo separato e annotato con @Before in modo che venga eseguito prima del test case sum_isCorrect e multiply_isCorrect . Il codice completo è il seguente,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   Computation computation = null;
   @Before
   public void CreateComputationObject() {
      this.computation = new Computation();
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, this.computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, this.computation.Multiply(2,2));
   }
}

@Dopo

@After è simile a @Before , ma il metodo annotato con @After verrà chiamato o eseguito dopo l'esecuzione di ogni test case. Il codice di esempio è il seguente,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   Computation computation = null;
   @Before
   public void CreateComputationObject() {
      this.computation = new Computation();
   }
   @After
   public void DestroyComputationObject() {
      this.computation = null;
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, this.computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, this.computation.Multiply(2,2));
   }
}

@Prima della lezione

@BeforeClass è simile a @Before , ma il metodo annotato con @BeforeClass verrà chiamato o eseguito solo una volta prima di eseguire tutti i casi di test in una particolare classe. È utile creare oggetti ad alta intensità di risorse come un oggetto di connessione al database. Ciò ridurrà il tempo necessario per eseguire una raccolta di casi di test. Questo metodo deve essere statico per funzionare correttamente. Nel nostro esempio, possiamo creare l'oggetto di calcolo una volta prima di eseguire tutti i casi di test come specificato di seguito,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   private static Computation computation = null;
   @BeforeClass
   public static void CreateComputationObject() {
      computation = new Computation();
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, computation.Multiply(2,2));
   }
}

@Dopo la lezione

@AfterClass è simile a @BeforeClass , ma il metodo annotato con @AfterClass verrà chiamato o eseguito solo una volta dopo che tutti i casi di test in una particolare classe saranno stati eseguiti. Anche questo metodo deve essere statico per funzionare correttamente. Il codice di esempio è il seguente:

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   private static Computation computation = null;
   @BeforeClass
   public static void CreateComputationObject() {
      computation = new Computation();
   }
   @AfterClass
   public static void DestroyComputationObject() {
      computation = null;
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, computation.Multiply(2,2));
   }
}

@Regola

L' annotazione @Rule è uno dei punti salienti di JUnit . Viene utilizzato per aggiungere comportamenti ai casi di test. Possiamo solo annotare i campi di tipo TestRule . In realtà fornisce un set di funzionalità fornito dalle annotazioni @Before e @After ma in modo efficiente e riutilizzabile. Ad esempio, potremmo aver bisogno di una cartella temporanea per memorizzare alcuni dati durante un caso di test. Normalmente, è necessario creare una cartella temporanea prima di eseguire il test case (utilizzando l'annotazione @Before o @BeforeClass) e distruggerla dopo l'esecuzione del test case (utilizzando l'annotazione @After o @AfterClass). Invece, possiamo usare la classe TemporaryFolder (di tipo TestRule ) fornita dal framework JUnit per creare una cartella temporanea per tutti i nostri casi di test e la cartella temporanea verrà eliminata come e quando viene eseguito il caso di test. Dobbiamo creare una nuova variabile di tipo TemporaryFolder e dobbiamo annotare con @Rule come specificato di seguito,

package com.tutorialspoint.espressosamples.helloworldapp;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import java.io.File;
import java.io.IOException;
import static junit.framework.TestCase.assertTrue;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   private static Computation computation = null;
   @Rule
   public TemporaryFolder folder = new TemporaryFolder();
   @Test
   public void file_isCreated() throws IOException {
      folder.newFolder("MyTestFolder");
      File testFile = folder.newFile("MyTestFile.txt");
      assertTrue(testFile.exists());
   }
   @BeforeClass
   public static void CreateComputationObject() {
      computation = new Computation();
   }
   @AfterClass
   public static void DestroyComputationObject() {
      computation = null;
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, computation.Multiply(2,2));
   }
}

Ordine di esecuzione

In JUnit , i metodi annotati con annotazioni diverse verranno eseguiti in un ordine specifico come mostrato di seguito,

@BeforeClass
@Rule
@Before
@Test
@After
@AfterClass

Asserzione

L'asserzione è un modo per verificare se il valore atteso dello scenario di test corrisponde al valore effettivo del risultato dello scenario di test. JUnit fornisce asserzioni per diversi scenari; di seguito sono elencate alcune importanti affermazioni:

fail() - Far fallire esplicitamente un test case.
assertTrue(boolean test_condition) - Verifica che test_condition sia vero
assertFalse(boolean test_condition) - Verifica che test_condition sia falso
assertEquals(expected, actual) - Verifica che entrambi i valori siano uguali
assertNull(object) - Verifica che l'oggetto sia nullo
assertNotNull(object) - Verifica che l'oggetto non sia nullo
assertSame(expected, actual) - Verifica che entrambi facciano riferimento allo stesso oggetto.
assertNotSame(expected, actual) - Verifica che entrambi facciano riferimento a oggetti diversi.