Framework de test Espresso - Présentation de JUnit

Dans ce chapitre, laissez-nous comprendre les bases de JUnit , le framework de test unitaire populaire développé par la communauté Java sur lequel le framework de test d'espresso est construit.

JUnit est le standard de facto pour les tests unitaires d'une application Java. Même s'il est populaire pour les tests unitaires, il offre également un support complet et une disposition pour les tests d'instrumentation. La bibliothèque de tests Espresso étend les classes JUnit nécessaires pour prendre en charge les tests d'instrumentation basés sur Android.

Rédiger un test unitaire simple

Créons une classe Java, Computation (Computation.java) et écrivons une opération mathématique simple, Summation et Multiplication . Ensuite, nous écrirons des cas de test en utilisant JUnit et le vérifierons en exécutant les cas de test.

Démarrez Android Studio.
Ouvrez HelloWorldApp créé dans le chapitre précédent.
Créez un fichier, Computation.java dans app / src / main / java / com / tutorialspoint / espressosamples / helloworldapp / et écrivez deux fonctions - Sum et Multiply comme spécifié ci-dessous,

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

Créez un fichier, ComputationUnitTest.java dans app / src / test / java / com / tutorialspoint / espressosamples / helloworldapp et écrivez des cas de test unitaires pour tester les fonctionnalités de somme et de multiplication comme spécifié ci-dessous

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

Ici, nous avons utilisé deux nouveaux termes - @Test et assertEquals . En général, JUnit utilise l'annotation Java pour identifier les cas de test dans une classe et des informations sur la façon d'exécuter les cas de test. @Test est l'une de ces annotations Java, qui spécifie que la fonction particulière est un cas de test junit. assertEquals est une fonction pour affirmer que le premier argument (valeur attendue) et le second argument (valeur calculée) sont égaux et identiques. JUnit fournit un certain nombre de méthodes d'assertion pour différents scénarios de test.

Maintenant, exécutez ComputationUnitTest dans le studio Android en cliquant avec le bouton droit de la souris sur la classe et en invoquant l' option Exécuter 'ComputationUnitTest' comme expliqué dans le chapitre précédent. Cela exécutera les cas de test unitaires et signalera le succès.

Le résultat du test unitaire de calcul est comme indiqué ci-dessous -

Annotations

Le framework JUnit utilise largement l'annotation . Certaines des annotations importantes sont les suivantes -

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

Annotation @Test

@Test est l'annotation très importante du framework JUnit . @Test est utilisé pour différencier une méthode normale de la méthode de cas de test. Une fois qu'une méthode est décorée avec l' annotation @Test , cette méthode particulière est considérée comme un cas de test et sera exécutée par JUnit Runner . JUnit Runner est une classe spéciale, qui est utilisée pour rechercher et exécuter les cas de test JUnit disponibles dans les classes java. Pour l'instant, nous utilisons l' option intégrée d'Android Studio pour exécuter les tests unitaires (qui à leur tour exécutent JUnit Runner ). Un exemple de code est le suivant,

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

@Avant

L' annotation @Before est utilisée pour faire référence à une méthode, qui doit être appelée avant d'exécuter une méthode de test disponible dans une classe de test particulière. Par exemple, dans notre exemple, l' objet Computation peut être créé dans une méthode distincte et annoté avec @Before afin qu'il s'exécute avant le cas de test sum_isCorrect et multiply_isCorrect . Le code complet est le suivant,

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

@Après

@After est similaire à @Before , mais la méthode annotée avec @After sera appelée ou exécutée après l'exécution de chaque scénario de test. L'exemple de code est le suivant,

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

@Avant les cours

@BeforeClass est similaire à @Before , mais la méthode annotée avec @BeforeClass ne sera appelée ou exécutée qu'une seule fois avant d'exécuter tous les cas de test dans une classe particulière. Il est utile de créer un objet gourmand en ressources comme un objet de connexion à la base de données. Cela réduira le temps d'exécution d'une collection de cas de test. Cette méthode doit être statique pour fonctionner correctement. Dans notre exemple, nous pouvons créer l'objet de calcul une fois avant d'exécuter tous les cas de test comme spécifié ci-dessous,

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

@Après les cours

@AfterClass est similaire à @BeforeClass , mais la méthode annotée avec @AfterClass ne sera appelée ou exécutée qu'une seule fois après l'exécution de tous les cas de test d'une classe particulière. Cette méthode doit également être statique pour fonctionner correctement. L'exemple de code est le suivant -

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

@Règle

L' annotation @Rule est l'un des points forts de JUnit . Il est utilisé pour ajouter un comportement aux cas de test. Nous ne pouvons annoter que les champs de type TestRule . Il fournit en fait un ensemble de fonctionnalités fournies par les annotations @Before et @After, mais de manière efficace et réutilisable. Par exemple, nous pouvons avoir besoin d'un dossier temporaire pour stocker certaines données pendant un cas de test. Normalement, nous devons créer un dossier temporaire avant d'exécuter le scénario de test (en utilisant l'annotation @Before ou @BeforeClass) et le détruire après l'exécution du scénario de test (en utilisant l'annotation @After ou @AfterClass). Au lieu de cela, nous pouvons utiliser la classe TemporaryFolder (de type TestRule ) fournie par le framework JUnit pour créer un dossier temporaire pour tous nos cas de test et le dossier temporaire sera supprimé au fur et à mesure de l'exécution du scénario de test. Nous devons créer une nouvelle variable de type TemporaryFolder et annoter avec @Rule comme spécifié ci-dessous,

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

Ordre d'exécution

Dans JUnit , les méthodes annotées avec des annotations différentes seront exécutées dans un ordre spécifique comme indiqué ci-dessous,

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

Affirmation

L'assertion est un moyen de vérifier si la valeur attendue du scénario de test correspond à la valeur réelle du résultat du scénario de test. JUnit fournit une assertion pour différents scénarios; quelques affirmations importantes sont énumérées ci-dessous -

fail() - Pour faire échouer explicitement un cas de test.
assertTrue(boolean test_condition) - Vérifie que la condition test_condition est vraie
assertFalse(boolean test_condition) - Vérifie que la condition test_condition est fausse
assertEquals(expected, actual) - Vérifie que les deux valeurs sont égales
assertNull(object) - Vérifie que l'objet est nul
assertNotNull(object) - Vérifie que l'objet n'est pas nul
assertSame(expected, actual) - Vérifie que les deux font référence au même objet.
assertNotSame(expected, actual) - Vérifie que les deux font référence à un objet différent.

↰ Previous page Next page ↱