Marco de prueba de Espresso: descripción general de JUnit

En este capítulo, comprendamos los conceptos básicos de JUnit , el popular marco de pruebas unitarias desarrollado por la comunidad Java sobre el que se construye el marco de pruebas espresso.

JUnit es el estándar de facto para la prueba unitaria de una aplicación Java. Aunque es popular para las pruebas unitarias, también cuenta con soporte completo y provisión para pruebas de instrumentación. La biblioteca de pruebas Espresso amplía las clases JUnit necesarias para admitir las pruebas de instrumentación basadas en Android.

Escribir una prueba unitaria simple

Creemos una clase Java, Computación (Computation.java) y escribamos una operación matemática simple, Suma y Multiplicación . Luego, escribiremos casos de prueba usando JUnit y lo verificaremos ejecutando los casos de prueba.

Inicie Android Studio.
Abra HelloWorldApp creada en el capítulo anterior.
Cree un archivo, Computation.java en app / src / main / java / com / tutorialspoint / espressosamples / helloworldapp / y escriba dos funciones: Suma y Multiplica como se especifica a continuación,

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

Cree un archivo, ComputationUnitTest.java en app / src / test / java / com / tutorialspoint / espressosamples / helloworldapp y escriba casos de prueba unitarios para probar la funcionalidad de suma y multiplicación como se especifica a continuación

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

Aquí, hemos utilizado dos términos nuevos: @Test y assertEquals . En general, JUnit usa la anotación de Java para identificar los casos de prueba en una clase e información sobre cómo ejecutar los casos de prueba. @Test es una de esas anotaciones de Java, que especifica que la función en particular es un caso de prueba junit. assertEquals es una función para afirmar que el primer argumento (valor esperado) y el segundo argumento (valor calculado) son iguales. JUnit proporciona una serie de métodos de afirmación para diferentes escenarios de prueba.

Ahora, ejecute ComputationUnitTest en el estudio de Android haciendo clic derecho en la clase e invocando la opción Ejecutar 'ComputationUnitTest' como se explicó en el capítulo anterior. Esto ejecutará los casos de prueba unitarios e informará el éxito.

El resultado de la prueba unitaria de cálculo es el que se muestra a continuación:

Anotaciones

El marco JUnit utiliza la anotación de forma extensiva . Algunas de las anotaciones importantes son las siguientes:

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

@ Anotación de prueba

@Test es la anotación muy importante en el marco JUnit . @Test se utiliza para diferenciar un método normal del método de caso de prueba. Una vez que un método está decorado con la anotación @Test , ese método en particular se considera un caso de prueba y lo ejecutará JUnit Runner . JUnit Runner es una clase especial, que se utiliza para buscar y ejecutar los casos de prueba JUnit disponibles dentro de las clases java. Por ahora, estamos usando la opción incorporada de Android Studio para ejecutar las pruebas unitarias (que a su vez ejecutan JUnit Runner ). Un código de muestra es el siguiente,

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

@Antes de

La anotación @Before se usa para hacer referencia a un método, que debe invocarse antes de ejecutar cualquier método de prueba disponible en una clase de prueba en particular. Por ejemplo, en nuestra muestra, el objeto Computation puede crearse en un método separado y anotarse con @Before para que se ejecute antes del caso de prueba sum_isCorrect y multiply_isCorrect . El código completo es el siguiente,

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

@Después

@After es similar a @Before , pero el método anotado con @After se llamará o ejecutará después de ejecutar cada caso de prueba. El código de muestra es el siguiente,

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

@Antes de clase

@BeforeClass es similar a @Before , pero el método anotado con @BeforeClass se llamará o ejecutará solo una vez antes de ejecutar todos los casos de prueba en una clase en particular. Es útil crear un objeto de uso intensivo de recursos como un objeto de conexión de base de datos. Esto reducirá el tiempo necesario para ejecutar una colección de casos de prueba. Este método debe ser estático para que funcione correctamente. En nuestra muestra, podemos crear el objeto de cálculo una vez antes de ejecutar todos los casos de prueba como se especifica a continuación,

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

@Después de clases

@AfterClass es similar a @BeforeClass , pero el método anotado con @AfterClass se llamará o ejecutará solo una vez después de que se ejecuten todos los casos de prueba en una clase en particular. Este método también debe ser estático para funcionar correctamente. El código de muestra es el siguiente:

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

@Regla

La anotación @Rule es uno de los aspectos más destacados de JUnit . Se utiliza para agregar comportamiento a los casos de prueba. Solo podemos anotar los campos de tipo TestRule . En realidad, el conjunto de características proporciona proporcionada por @Before y @After anotación pero de una manera eficiente y reutilizable. Por ejemplo, es posible que necesitemos una carpeta temporal para almacenar algunos datos durante un caso de prueba. Normalmente, necesitamos crear una carpeta temporal antes de ejecutar el caso de prueba (usando la anotación @Before o @BeforeClass) y destruirla después de ejecutar el caso de prueba (usando la anotación @After o @AfterClass). En su lugar, podemos usar la clase TemporaryFolder (de tipo TestRule ) proporcionada por JUnit framework para crear una carpeta temporal para todos nuestros casos de prueba y la carpeta temporal se eliminará cuando se ejecute el caso de prueba. Necesitamos crear una nueva variable de tipo TemporaryFolder y necesitamos anotar con @Rule como se especifica a continuación,

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

Orden de ejecución

En JUnit , los métodos anotados con diferentes anotaciones se ejecutarán en un orden específico como se muestra a continuación,

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

Afirmación

La afirmación es una forma de comprobar si el valor esperado del caso de prueba coincide con el valor real del resultado del caso de prueba. JUnit proporciona afirmación para diferentes escenarios; Algunas afirmaciones importantes se enumeran a continuación:

fail() - Hacer que un caso de prueba falle explícitamente.
assertTrue(boolean test_condition) - Comprueba que test_condition sea verdadero
assertFalse(boolean test_condition) - Comprueba que test_condition sea falso
assertEquals(expected, actual) - Comprueba que ambos valores sean iguales
assertNull(object) - Comprueba que el objeto sea nulo
assertNotNull(object) - Comprueba que el objeto no sea nulo
assertSame(expected, actual) - Comprueba que ambos se refieren al mismo objeto.
assertNotSame(expected, actual) - Comprueba que ambos se refieren a objeto diferente.

↰ Previous page Next page ↱