Framework testowania espresso - przegląd JUnit

W tym rozdziale zapoznajmy się z podstawami JUnit , popularnego frameworka do testów jednostkowych opracowanego przez społeczność Java, na podstawie którego zbudowana jest platforma testowania espresso.

JUnit jest de facto standardem testowania jednostkowego aplikacji Java. Mimo że jest popularny do testowania jednostkowego, ma pełne wsparcie i możliwość testowania oprzyrządowania. Biblioteka testująca Espresso rozszerza niezbędne klasy JUnit do obsługi testowania oprzyrządowania opartego na systemie Android.

Napisz prosty test jednostkowy

Stwórzmy klasę Java, Computation (Computation.java) i napiszmy proste operacje matematyczne, Sumowanie i Mnożenie . Następnie napiszemy przypadki testowe za pomocą JUnit i sprawdzimy je uruchamiając przypadki testowe.

Uruchom Android Studio.
Otwórz aplikację HelloWorldApp utworzoną w poprzednim rozdziale.
Utwórz plik Computation.java w app / src / main / java / com / tutorialspoint / espressosamples / helloworldapp / i napisz dwie funkcje - Sum i Multiply jak określono poniżej,

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

Utwórz plik ComputationUnitTest.java w app / src / test / java / com / tutorialspoint / espressosamples / helloworldapp i napisz przypadki testów jednostkowych w celu przetestowania funkcji Sum i Multiply, jak określono poniżej

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

Tutaj użyliśmy dwóch nowych terminów - @Test i assertEquals . Ogólnie rzecz biorąc, JUnit używa adnotacji Java do identyfikacji przypadków testowych w klasie i informacji o tym, jak wykonać przypadki testowe. @Test to jedna z takich adnotacji Java, która określa, że dana funkcja jest przypadkiem testowym junit. assertEquals to funkcja zapewniająca, że pierwszy argument (wartość oczekiwana) i drugi argument (wartość obliczona) są równe i takie same. JUnit zapewnia szereg metod asercji dla różnych scenariuszy testowych.

Teraz uruchom ComputationUnitTest w studiu Android, klikając prawym przyciskiem myszy klasę i wywołując opcję Uruchom „ComputationUnitTest” , jak wyjaśniono w poprzednim rozdziale. Spowoduje to uruchomienie przypadków testów jednostkowych i zgłoszenie sukcesu.

Wynik testu jednostki obliczeniowej jest pokazany poniżej -

Adnotacje

Struktura JUnit intensywnie używa adnotacji . Oto niektóre ważne adnotacje -

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

@ Adnotacja testowa

@Test to bardzo ważna adnotacja we frameworku JUnit . @Test służy do odróżnienia metody normalnej od metody przypadku testowego. Gdy metoda jest ozdobiona adnotacją @Test , ta konkretna metoda jest traktowana jako przypadek testowy i zostanie uruchomiona przez JUnit Runner . JUnit Runner to specjalna klasa, która służy do znajdowania i uruchamiania przypadków testowych JUnit dostępnych w klasach java. Na razie używamy wbudowanej opcji Android Studio do uruchamiania testów jednostkowych (które z kolei uruchamiają JUnit Runner ). Przykładowy kod jest następujący:

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

@Przed

@Before adnotacja służy do odwoływania się do metody, którą należy wywołać przed uruchomieniem dowolnej metody testowej dostępnej w określonej klasie testowej. Na przykład w naszym przykładzie obiekt Computation można utworzyć w oddzielnej metodzie i opatrzyć adnotacją @Before, tak aby działał przed przypadkiem testowym sum_isCorrect i multiply_isCorrect . Pełny kod jest następujący,

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

@Po

@After jest podobny do @Before , ale metoda z adnotacją @After zostanie wywołana lub wykonana po uruchomieniu każdego przypadku testowego. Przykładowy kod jest następujący:

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

@Przed zajęciami

@BeforeClass jest podobny do @Before , ale metoda z adnotacją @BeforeClass zostanie wywołana lub wykonana tylko raz przed uruchomieniem wszystkich przypadków testowych w określonej klasie. Przydatne jest tworzenie obiektów intensywnie korzystających z zasobów, takich jak obiekt połączenia z bazą danych. Skróci to czas wykonywania kolekcji przypadków testowych. Ta metoda musi być statyczna, aby działała poprawnie. W naszym przykładzie możemy utworzyć obiekt obliczeniowy jeden raz przed uruchomieniem wszystkich przypadków testowych, jak określono poniżej,

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

@Po zajęciach

@AfterClass jest podobny do @BeforeClass , ale metoda z adnotacją @AfterClass zostanie wywołana lub wykonana tylko raz po uruchomieniu wszystkich przypadków testowych w określonej klasie. Ta metoda również musi być statyczna, aby działała prawidłowo. Przykładowy kod jest następujący -

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

@Reguła

Adnotacja @Rule jest jedną z najważniejszych cech JUnit . Służy do dodawania zachowania do przypadków testowych. Możemy dodawać adnotacje tylko do pól typu TestRule . W rzeczywistości zapewnia zestaw funkcji zapewniany przez adnotacje @Before i @After, ale w wydajny i wielokrotnego użytku sposób. Na przykład, możemy potrzebować tymczasowego folderu do przechowywania niektórych danych podczas testu. Zwykle przed uruchomieniem przypadku testowego musimy utworzyć folder tymczasowy (używając adnotacji @Before lub @BeforeClass) i zniszczyć go po uruchomieniu przypadku testowego (używając adnotacji @After lub @AfterClass). Zamiast tego możemy użyć klasy TemporaryFolder (typu TestRule ) dostarczonej przez platformę JUnit , aby utworzyć folder tymczasowy dla wszystkich naszych przypadków testowych, a folder tymczasowy zostanie usunięty w momencie uruchomienia przypadku testowego. Musimy utworzyć nową zmienną typu TemporaryFolder i dodać adnotację @Rule, jak określono poniżej,

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

Kolejność wykonania

W JUnit metody z adnotacjami z różnymi adnotacjami będą wykonywane w określonej kolejności, jak pokazano poniżej,

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

Twierdzenie

Asercja to sposób sprawdzenia, czy oczekiwana wartość przypadku testowego odpowiada rzeczywistej wartości wyniku przypadku testowego. JUnit zapewnia asercję dla różnych scenariuszy; kilka ważnych stwierdzeń jest wymienionych poniżej -

fail() - jawnie uniemożliwić przypadek testowy.
assertTrue(boolean test_condition) - Sprawdza, czy warunek testowy jest prawdziwy
assertFalse(boolean test_condition) - Sprawdza, czy warunek testowy jest fałszywy
assertEquals(expected, actual) - Sprawdza, czy obie wartości są równe
assertNull(object) - Sprawdza, czy obiekt jest pusty
assertNotNull(object) - Sprawdza, czy obiekt nie jest pusty
assertSame(expected, actual) - Sprawdza, czy oba odnoszą się do tego samego obiektu.
assertNotSame(expected, actual) - Sprawdza, czy oba odnoszą się do innego obiektu.