Espresso Testing Framework - Überblick über JUnit

Lassen Sie uns in diesem Kapitel die Grundlagen von JUnit verstehen , dem beliebten Unit-Testing-Framework, das von der Java-Community entwickelt wurde und auf dem das Espresso-Test-Framework basiert.

JUnit ist der De-facto-Standard für Unit-Tests einer Java-Anwendung. Obwohl es für Unit-Tests beliebt ist, bietet es vollständige Unterstützung und Bereitstellung für Instrumententests. Die Espresso-Testbibliothek erweitert die erforderlichen JUnit-Klassen, um die Android-basierten Instrumententests zu unterstützen.

Schreiben Sie einen einfachen Komponententest

Erstellen wir eine Java-Klasse, Computation (Computation.java), und schreiben Sie eine einfache mathematische Operation, Summation und Multiplikation . Anschließend schreiben wir Testfälle mit JUnit und überprüfen sie, indem wir die Testfälle ausführen.

• Starten Sie Android Studio.

• Öffnen Sie die im vorherigen Kapitel erstellte HelloWorldApp .

• Erstellen Sie eine Datei, Computation.java in app / src / main / java / com / tutorialspoint / espressosamples / HelloWorldApp / und Schreib zwei Funktionen - Summe und Multiplizieren , wie unten angegeben,

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;
   }
}

• Erstellen Sie eine Datei, ComputationUnitTest.java, in app / src / test / java / com / tutorialspoint / espressosamples / helloworldapp und schreiben Sie Unit-Testfälle, um die Summen- und Multiplikationsfunktionalität wie unten angegeben zu testen

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));
   }
}

Hier haben wir zwei neue Begriffe verwendet - @Test und assertEquals . Im Allgemeinen verwendet JUnit Java-Annotationen, um die Testfälle in einer Klasse zu identifizieren und Informationen zum Ausführen der Testfälle zu erhalten. @Test ist eine solche Java-Annotation, die angibt, dass die bestimmte Funktion ein Junit-Testfall ist. assertEquals ist eine Funktion, mit der bestätigt wird, dass das erste Argument (erwarteter Wert) und das zweite Argument (berechneter Wert) gleich und gleich sind. JUnit bietet eine Reihe von Assertionsmethoden für verschiedene Testszenarien.

• Führen Sie nun den ComputationUnitTest im Android Studio aus, indem Sie mit der rechten Maustaste auf die Klasse klicken und die Option 'ComputationUnitTest' ausführen aufrufen , wie im vorherigen Kapitel erläutert. Dadurch werden die Unit-Testfälle ausgeführt und der Erfolg gemeldet.

Das Ergebnis des Berechnungseinheitentests ist wie folgt:

Anmerkungen

Das JUnit-Framework verwendet Annotationen in großem Umfang . Einige der wichtigen Anmerkungen sind wie folgt:

• @Test

• @Before

• @After

• @BeforeClass

• @AfterClass

• @Rule

@ Test Annotation

@Test ist die sehr wichtige Anmerkung im JUnit- Framework. @Test wird verwendet, um eine normale Methode von der Testfallmethode zu unterscheiden. Sobald eine Methode mit der Annotation @Test versehen ist , wird diese bestimmte Methode als Testfall betrachtet und von JUnit Runner ausgeführt . JUnit Runner ist eine spezielle Klasse, mit der die in den Java-Klassen verfügbaren JUnit-Testfälle gefunden und ausgeführt werden. Derzeit verwenden wir die integrierte Option von Android Studio, um die Komponententests auszuführen (auf denen wiederum der JUnit Runner ausgeführt wird ). Ein Beispielcode lautet wie folgt:

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));
   }
}

@Vor

@Before Annotation wird verwendet, um auf eine Methode zu verweisen, die aufgerufen werden muss, bevor eine in einer bestimmten Testklasse verfügbare Testmethode ausgeführt wird. In unserem Beispiel kann das Berechnungsobjekt beispielsweise in einer separaten Methode erstellt und mit @Before versehen werden, sodass es vor dem Testfall sum_isCorrect und multiply_isCorrect ausgeführt wird. Der vollständige Code lautet wie folgt:

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));
   }
}

@Nach

@After ähnelt @Before , aber die mit @After kommentierte Methode wird aufgerufen oder ausgeführt, nachdem jeder Testfall ausgeführt wurde. Der Beispielcode lautet wie folgt:

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));
   }
}

@Vor dem Unterricht

@BeforeClass ähnelt @Before , aber die mit @BeforeClass kommentierte Methode wird nur einmal aufgerufen oder ausgeführt, bevor alle Testfälle in einer bestimmten Klasse ausgeführt werden. Es ist nützlich, ein ressourcenintensives Objekt wie ein Datenbankverbindungsobjekt zu erstellen. Dies verkürzt die Zeit zum Ausführen einer Sammlung von Testfällen. Diese Methode muss statisch sein, um ordnungsgemäß zu funktionieren. In unserem Beispiel können wir das Berechnungsobjekt einmal erstellen, bevor wir alle unten angegebenen Testfälle ausführen.

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));
   }
}

@Nach dem Unterricht

@AfterClass ähnelt @BeforeClass , aber die mit @AfterClass kommentierte Methode wird nur einmal aufgerufen oder ausgeführt, nachdem alle Testfälle in einer bestimmten Klasse ausgeführt wurden. Diese Methode muss auch statisch sein, um ordnungsgemäß zu funktionieren. Der Beispielcode lautet wie folgt:

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));
   }
}

@Regel

Die @ Regel- Annotation ist eines der Highlights von JUnit . Es wird verwendet, um den Testfällen Verhalten hinzuzufügen. Wir können nur die Felder vom Typ TestRule mit Anmerkungen versehen . Es bietet tatsächlich Funktionen, die durch Annotation @Before und @After bereitgestellt werden, jedoch auf effiziente und wiederverwendbare Weise. Beispielsweise benötigen wir möglicherweise einen temporären Ordner, um einige Daten während eines Testfalls zu speichern. Normalerweise müssen wir einen temporären Ordner erstellen, bevor wir den Testfall ausführen (entweder mit der Annotation @Before oder @BeforeClass) und ihn zerstören, nachdem der Testfall ausgeführt wurde (entweder mit der Annotation @After oder @AfterClass). Stattdessen können wir die vom JUnit- Framework bereitgestellte TemporaryFolder- Klasse (vom Typ TestRule ) verwenden , um einen temporären Ordner für alle unsere Testfälle zu erstellen. Der temporäre Ordner wird gelöscht, sobald der Testfall ausgeführt wird. Wir müssen eine neue Variable vom Typ TemporaryFolder erstellen und mit @Rule kommentieren, wie unten angegeben.

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));
   }
}

Ausführungsreihenfolge

In JUnit werden die mit unterschiedlichen Anmerkungen versehenen Methoden in einer bestimmten Reihenfolge ausgeführt, wie unten gezeigt.

• @BeforeClass

• @Rule

• @Before

• @Test

• @After

• @AfterClass

Behauptung

Durch die Bestätigung kann überprüft werden, ob der erwartete Wert des Testfalls mit dem tatsächlichen Wert des Testergebnises übereinstimmt. JUnit bietet Zusicherungen für verschiedene Szenarien. Einige wichtige Aussagen sind unten aufgeführt -

• fail() - Um einen Testfall explizit zum Scheitern zu bringen.

• assertTrue(boolean test_condition) - Überprüft, ob die test_condition wahr ist

• assertFalse(boolean test_condition) - Überprüft, ob die test_condition falsch ist

• assertEquals(expected, actual) - Überprüft, ob beide Werte gleich sind

• assertNull(object) - Überprüft, ob das Objekt null ist

• assertNotNull(object) - Überprüft, ob das Objekt nicht null ist

• assertSame(expected, actual) - Überprüft, ob beide auf dasselbe Objekt verweisen.

• assertNotSame(expected, actual) - Überprüft, ob beide unterschiedliche Objekte referenzieren.