JUnit - Guía rápida

La prueba es el proceso de verificar la funcionalidad de una aplicación para asegurarse de que se ejecuta según los requisitos. Las pruebas unitarias entran en escena a nivel de los desarrolladores; es la prueba de una sola entidad (clase o método). Las pruebas unitarias desempeñan un papel fundamental para ayudar a una empresa de software a ofrecer productos de calidad a sus clientes.

Las pruebas unitarias se pueden realizar de dos formas: pruebas manuales y pruebas automatizadas.

Prueba manual Pruebas automatizadas
La ejecución de casos de prueba manualmente sin ningún soporte de herramientas se conoce como prueba manual. Tomar el soporte de herramientas y ejecutar los casos de prueba mediante el uso de una herramienta de automatización se conoce como prueba de automatización.
Time-consuming and tedious - Dado que los casos de prueba son ejecutados por recursos humanos, es muy lento y tedioso. Fast - La automatización ejecuta casos de prueba significativamente más rápido que los recursos humanos.
Huge investment in human resources - Como los casos de prueba deben ejecutarse manualmente, se requieren más probadores en las pruebas manuales. Less investment in human resources - Los casos de prueba se ejecutan utilizando herramientas de automatización, por lo que se requiere menos cantidad de probadores en las pruebas de automatización.
Less reliable - Las pruebas manuales son menos fiables, ya que deben tener en cuenta los errores humanos. More reliable - Las pruebas de automatización son precisas y fiables.
Non-programmable - No se puede realizar ninguna programación para escribir pruebas sofisticadas para obtener información oculta. Programmable - Los probadores pueden programar pruebas sofisticadas para sacar información oculta.

¿Qué es JUnit?

JUnit es un marco de pruebas unitarias para el lenguaje de programación Java. Desempeña un papel crucial en el desarrollo impulsado por pruebas y es una familia de marcos de pruebas unitarias conocidos colectivamente como xUnit.

JUnit promueve la idea de "primero probar y luego codificar", que enfatiza la configuración de los datos de prueba para un fragmento de código que se puede probar primero y luego implementar. Este enfoque es como "probar un poco, codificar un poco, probar un poco, codificar un poco". Aumenta la productividad del programador y la estabilidad del código del programa, lo que a su vez reduce el estrés del programador y el tiempo dedicado a la depuración.

Características de JUnit

  • JUnit es un marco de código abierto, que se utiliza para escribir y ejecutar pruebas.

  • Proporciona anotaciones para identificar métodos de prueba.

  • Proporciona afirmaciones para probar los resultados esperados.

  • Proporciona corredores de prueba para ejecutar pruebas.

  • Las pruebas JUnit le permiten escribir códigos más rápido, lo que aumenta la calidad.

  • JUnit es elegantemente simple. Es menos complejo y lleva menos tiempo.

  • Las pruebas JUnit se pueden ejecutar automáticamente y verifican sus propios resultados y brindan retroalimentación inmediata. No es necesario revisar manualmente un informe de resultados de prueba.

  • Las pruebas de JUnit se pueden organizar en conjuntos de pruebas que contienen casos de prueba e incluso otros conjuntos de pruebas.

  • JUnit muestra el progreso de la prueba en una barra que es verde si la prueba se está ejecutando sin problemas y se vuelve roja cuando falla una prueba.

¿Qué es un caso de prueba unitario?

Un caso de prueba unitario es parte del código, lo que garantiza que otra parte del código (método) funcione como se espera. Para lograr los resultados deseados rápidamente, se requiere un marco de prueba. JUnit es un marco de prueba unitario perfecto para el lenguaje de programación Java.

Un caso de prueba unitario escrito formal se caracteriza por una entrada conocida y una salida esperada, que se resuelve antes de ejecutar la prueba. La entrada conocida debe probar una condición previa y la salida esperada debe probar una condición posterior.

Debe haber al menos dos casos de prueba unitarios para cada requisito: una prueba positiva y una prueba negativa. Si un requisito tiene subrequisitos, cada subrequisito debe tener al menos dos casos de prueba como positivos y negativos.

Configuración del entorno local

JUnit es un marco para Java, por lo que el primer requisito es tener JDK instalado en su máquina.

Requisitos del sistema

JDK 1,5 o superior.
Memoria Sin requisitos mínimos.
Espacio del disco Sin requisitos mínimos.
Sistema operativo Sin requisitos mínimos.

Paso 1: Verifique la instalación de Java en su máquina

En primer lugar, abra la consola y ejecute un comando java basado en el sistema operativo en el que está trabajando.

SO Tarea Mando
Ventanas Abrir consola de comandos c: \> java -version
Linux Terminal de comando abierto $ java -version
Mac Terminal abierta máquina: ~ joseph $ java -version

Verifiquemos la salida para todos los sistemas operativos:

SO Salida
Ventanas

versión de Java "1.8.0_101"

Entorno de ejecución Java (TM) SE (compilación 1.8.0_101)

Linux

versión de Java "1.8.0_101"

Entorno de ejecución Java (TM) SE (compilación 1.8.0_101)

Mac

versión de Java "1.8.0_101"

Entorno de ejecución Java (TM) SE (compilación 1.8.0_101)

Si no tiene Java instalado en su sistema, descargue el Java Software Development Kit (SDK) desde el siguiente enlace https://www.oracle.com. Estamos asumiendo Java 1.8.0_101 como la versión instalada para este tutorial.

Paso 2: configurar el entorno JAVA

Selecciona el JAVA_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo.

SO Salida
Ventanas Establezca la variable de entorno JAVA_HOME en C: \ Archivos de programa \ Java \ jdk1.8.0_101
Linux exportar JAVA_HOME = / usr / local / java-current
Mac exportar JAVA_HOME = / Library / Java / Home

Agregue la ubicación del compilador de Java a la ruta del sistema.

SO Salida
Ventanas Añade la cadena C:\Program Files\Java\jdk1.8.0_101\bin al final de la variable del sistema, Path.
Linux export PATH = $PATH:$JAVA_HOME / bin /
Mac no requerido

Verifique la instalación de Java usando el comando java -version como se explicó anteriormente.

Paso 3: Descarga JUnit Archive

Descargue la última versión del archivo jar JUnit de http://www.junit.org. En el momento de escribir este tutorial, hemos descargado Junit-4.12.jar y lo hemos copiado en la carpeta C: \> JUnit.

SO Nombre de archivo
Ventanas junit4.12.jar
Linux junit4.12.jar
Mac junit4.12.jar

Paso 4: configurar el entorno JUnit

Selecciona el JUNIT_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde se almacena JUNIT jar en su máquina. Supongamos que hemos almacenado junit4.12.jar en la carpeta JUNIT.

No Señor SO y descripción
1

Windows

Establezca la variable de entorno JUNIT_HOME en C: \ JUNIT

2

Linux

exportar JUNIT_HOME = / usr / local / JUNIT

3

Mac

exportar JUNIT_HOME = / Library / JUNIT

Paso 5: Establecer la variable CLASSPATH

Selecciona el CLASSPATH variable de entorno para apuntar a la ubicación del jar de JUNIT.

No Señor SO y descripción
1

Windows

Establezca la variable de entorno CLASSPATH en% CLASSPATH%;% JUNIT_HOME% \ junit4.12.jar;.;

2

Linux

exportar CLASSPATH = $CLASSPATH:$INICIO_JUNIT / junit4.12.jar :.

3

Mac

exportar CLASSPATH = $CLASSPATH:$INICIO_JUNIT / junit4.12.jar :.

Paso 6: Pruebe la configuración de JUnit

Cree un nombre de archivo de clase java TestJunit en C:\>JUNIT_WORKSPACE

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
   @Test
	
   public void testAdd() {
      String str = "Junit is working fine";
      assertEquals("Junit is working fine",str);
   }
}

Cree un nombre de archivo de clase de Java TestRunner en C:\>JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Paso 7: verificar el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

Ahora ejecute Test Runner para ver el resultado de la siguiente manera:

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

true

JUnit es un Regression Testing Frameworkutilizado por los desarrolladores para implementar pruebas unitarias en Java, y acelerar la velocidad de programación y aumentar la calidad del código. JUnit Framework se puede integrar fácilmente con cualquiera de los siguientes:

  • Eclipse
  • Ant
  • Maven

Características de JUnit Test Framework

El marco de prueba JUnit proporciona las siguientes características importantes:

  • Fixtures
  • Suites de prueba
  • Corredores de prueba
  • Clases de JUnit

Accesorios

Fixtureses un estado fijo de un conjunto de objetos que se utiliza como línea de base para ejecutar pruebas. El propósito de un dispositivo de prueba es garantizar que exista un entorno bien conocido y fijo en el que se ejecuten las pruebas para que los resultados sean repetibles. Incluye -

  • método setUp (), que se ejecuta antes de cada invocación de prueba.
  • tearDown () método, que se ejecuta después de cada método de prueba.

Veamos un ejemplo:

import junit.framework.*;

public class JavaTest extends TestCase {
   protected int value1, value2;
   
   // assigning the values
   protected void setUp(){
      value1 = 3;
      value2 = 3;
   }

   // test method to add two values
   public void testAdd(){
      double result = value1 + value2;
      assertTrue(result == 6);
   }
}

Suites de prueba

Un conjunto de pruebas agrupa algunos casos de prueba unitarios y los ejecuta juntos. En JUnit, las anotaciones @RunWith y @Suite se utilizan para ejecutar la prueba de la suite. A continuación se muestra un ejemplo que usa las clases de prueba TestJunit1 y TestJunit2.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

//JUnit Suite Test
@RunWith(Suite.class)

@Suite.SuiteClasses({ 
   TestJunit1.class ,TestJunit2.class
})

public class JunitTestSuite {
}
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Corredores de prueba

El corredor de pruebas se utiliza para ejecutar los casos de prueba. Aquí hay un ejemplo que asume la clase de pruebaTestJunit ya existe.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Clases de JUnit

Las clases de JUnit son clases importantes que se utilizan para escribir y probar JUnits. Algunas de las clases importantes son:

  • Assert - Contiene un conjunto de métodos de aserción.

  • TestCase - Contiene un caso de prueba que define el dispositivo para ejecutar múltiples pruebas.

  • TestResult - Contiene métodos para recopilar los resultados de la ejecución de un caso de prueba.

Tengamos ahora un ejemplo básico para demostrar el proceso paso a paso de usar JUnit.

Crear una clase

Cree una clase java para ser probada, digamos, MessageUtil.java en C:\>JUNIT_WORKSPACE

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
	
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Crear clase de caso de prueba

  • Cree una clase de prueba de Java, por ejemplo, TestJunit.java.
  • Agregue un método de prueba testPrintMessage () a su clase de prueba.
  • Agregue una Annotaion @Test al método testPrintMessage ().
  • Implemente la condición de prueba y verifique la condición usando la API assertEquals de JUnit.

Cree un nombre de archivo de clase java TestJunit.java en C:\>JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Crear clase de corredor de pruebas

  • Cree una clase Java de TestRunner.
  • Utilice el método runClasses de la clase JUnitCore de JUnit para ejecutar el caso de prueba de la clase de prueba creada anteriormente.
  • Obtenga el resultado de los casos de prueba ejecutados en el objeto de resultado.
  • Obtenga fallas usando el método getFailures () del objeto Result.
  • Obtenga un resultado exitoso utilizando el método wasSuccessful () del objeto Result.

Cree un archivo de clase java llamado TestRunner.java en C:\>JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases MessageUtil, Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

Hello World
true

Ahora actualice TestJunit en C:\>JUNIT_WORKSPACEpara que la prueba falle. Cambie la cadena del mensaje.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      message = "New Word";
      assertEquals(message,messageUtil.printMessage());
   }
}

Dejemos el resto de las clases como están e intentemos ejecutar el mismo Test Runner.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {

   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false

El paquete más importante de JUnit es junit.framework, que contiene todas las clases principales. Algunas de las clases importantes son las siguientes:

No Señor. Nombre de la clase Funcionalidad
1 Afirmar Un conjunto de métodos de aserción.
2 Caso de prueba Un caso de prueba define el dispositivo para ejecutar múltiples pruebas.
3 Resultado de la prueba Un TestResult recopila los resultados de la ejecución de un caso de prueba.
4 Banco de pruebas Un TestSuite es una combinación de pruebas.

Clase de afirmación

A continuación se muestra la declaración de org.junit.Assert clase -

public class Assert extends java.lang.Object

Esta clase proporciona un conjunto de métodos de afirmación útiles para escribir pruebas. Solo se registran las afirmaciones fallidas. Algunos de los métodos importantes de la clase Assert son los siguientes:

No Señor. Métodos y descripción
1

void assertEquals(boolean expected, boolean actual)

Comprueba que dos primitivas / objetos sean iguales.

2

void assertFalse(boolean condition)

Comprueba que una condición sea falsa.

3

void assertNotNull(Object object)

Comprueba que un objeto no sea nulo.

4

void assertNull(Object object)

Comprueba que un objeto sea nulo.

5

void assertTrue(boolean condition)

Comprueba que una condición sea verdadera.

6

void fail()

No pasa una prueba sin mensaje.

Usemos algunos de los métodos mencionados anteriormente en un ejemplo. Cree un archivo de clase java llamado TestJunit1.java enC:\>JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.*;

public class TestJunit1 {
   @Test
   public void testAdd() {
      //test data
      int num = 5;
      String temp = null;
      String str = "Junit is working fine";

      //check for equality
      assertEquals("Junit is working fine", str);
      
      //check for false condition
      assertFalse(num > 6);

      //check for not null value
      assertNotNull(temp);
   }
}

A continuación, cree un archivo de clase Java llamado TestRunner1.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner1 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit1.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile el caso de prueba y las clases Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner1

Verifique la salida.

true

Clase TestCase

A continuación se muestra la declaración de org.junit.TestCase clase -

public abstract class TestCase extends Assert implements Test

Un caso de prueba define el dispositivo para ejecutar múltiples pruebas. Algunos de los métodos importantes deTestCase clase son los siguientes:

No Señor. Métodos y descripción
1

int countTestCases()

Cuenta el número de casos de prueba ejecutados por ejecución (resultado de TestResult).

2

TestResult createResult()

Crea un objeto TestResult predeterminado.

3

String getName()

Obtiene el nombre de un TestCase.

4

TestResult run()

Un método conveniente para ejecutar esta prueba, recopilando los resultados con un objeto TestResult predeterminado.

5

void run(TestResult result)

Ejecuta el caso de prueba y recopila los resultados en TestResult.

6

void setName(String name)

Establece el nombre de un TestCase.

7

void setUp()

Configura el dispositivo, por ejemplo, abre una conexión de red.

8

void tearDown()

Derriba el dispositivo, por ejemplo, cierra una conexión de red.

9

String toString()

Devuelve una representación de cadena del caso de prueba.

Usemos algunos de los métodos mencionados anteriormente en un ejemplo. Cree un archivo de clase java llamadoTestJunit2.java en C: \> JUNIT_WORKSPACE.

import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;

public class TestJunit2 extends TestCase  {
   protected double fValue1;
   protected double fValue2;
   
   @Before 
   public void setUp() {
      fValue1 = 2.0;
      fValue2 = 3.0;
   }
	
   @Test
   public void testAdd() {
      //count the number of test cases
      System.out.println("No of Test Case = "+ this.countTestCases());
		
      //test getName 
      String name = this.getName();
      System.out.println("Test Case Name = "+ name);

      //test setName
      this.setName("testNewAdd");
      String newName = this.getName();
      System.out.println("Updated Test Case Name = "+ newName);
   }
	
   //tearDown used to close the connection or clean up activities
   public void tearDown(  ) {
   }
}

A continuación, cree un archivo de clase Java llamado TestRunner2.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner2 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit2.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile el caso de prueba y las clases Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner2

Verifique la salida.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true

Clase TestResult

A continuación se muestra la declaración de org.junit.TestResult clase -

public class TestResult extends Object

Un TestResult recopila los resultados de la ejecución de un caso de prueba. Es una instancia del patrón Collecting Parameter. El marco de prueba distingue entre fallas y errores. Una falla se anticipa y se verifica con afirmaciones. Los errores son problemas imprevistos como una excepción ArrayIndexOutOfBoundsException. Algunos de los métodos importantes deTestResult clase son los siguientes:

No Señor. Métodos y descripción
1

void addError(Test test, Throwable t)

Agrega un error a la lista de errores.

2

void addFailure(Test test, AssertionFailedError t)

Agrega una falla a la lista de fallas.

3

void endTest(Test test)

Informa el resultado de que se completó una prueba.

4

int errorCount()

Obtiene el número de errores detectados.

5

Enumeration<TestFailure> errors()

Devuelve una enumeración de los errores.

6

int failureCount()

Obtiene el número de fallas detectadas.

7

void run(TestCase test)

Ejecuta un TestCase.

8

int runCount()

Obtiene el número de pruebas ejecutadas.

9

void startTest(Test test)

Informa al resultado de que se iniciará una prueba.

10

void stop()

Señala que la ejecución de prueba debe detenerse.

Cree un archivo de clase java llamado TestJunit3.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import junit.framework.AssertionFailedError;
import junit.framework.TestResult;

public class TestJunit3 extends TestResult {
   // add the error
   public synchronized void addError(Test test, Throwable t) {
      super.addError((junit.framework.Test) test, t);
   }

   // add the failure
   public synchronized void addFailure(Test test, AssertionFailedError t) {
      super.addFailure((junit.framework.Test) test, t);
   }
	
   @Test
   public void testAdd() {
      // add any test
   }
   
   // Marks that the test run should stop.
   public synchronized void stop() {
      //stop the test here
   }
}

A continuación, cree un archivo de clase Java llamado TestRunner3.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner3 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit3.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile el caso de prueba y las clases Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner3

Verifique la salida.

true

Clase TestSuite

A continuación se muestra la declaración de org.junit.TestSuite clase:

public class TestSuite extends Object implements Test

Un TestSuite es un compuesto de pruebas. Ejecuta una colección de casos de prueba. Algunos de los métodos importantes deTestSuite clase son los siguientes:

No Señor. Métodos y descripción
1

void addTest(Test test)

Agrega una prueba a la suite.

2

void addTestSuite(Class<? extends TestCase> testClass)

Agrega las pruebas de la clase dada a la suite.

3

int countTestCases()

Cuenta el número de casos de prueba que ejecutará esta prueba.

4

String getName()

Devuelve el nombre de la suite.

5

void run(TestResult result)

Ejecuta las pruebas y recopila su resultado en un TestResult.

6

void setName(String name)

Establece el nombre de la suite.

7

Test testAt(int index)

Devuelve la prueba en el índice dado.

8

int testCount()

Devuelve el número de pruebas de esta suite.

9

static Test warning(String message)

Devuelve una prueba que fallará y registrará un mensaje de advertencia.

Cree un archivo de clase java llamado JunitTestSuite.java en C: \> JUNIT_WORKSPACE para crear la suite de pruebas.

import junit.framework.*;

public class JunitTestSuite {
   public static void main(String[] a) {
      // add the test's in the suite
      TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
      TestResult result = new TestResult();
      suite.run(result);
      System.out.println("Number of test cases = " + result.runCount());
   }
}

Compile las clases del conjunto de pruebas utilizando javac.

C:\JUNIT_WORKSPACE>javac JunitTestSuite.java

Ahora ejecute Test Suite.

C:\JUNIT_WORKSPACE>java JunitTestSuite

Verifique la salida.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3

Aquí veremos un ejemplo completo de prueba JUnit usando la clase POJO, la clase de lógica empresarial y una clase de prueba, que será ejecutada por el ejecutor de pruebas.

Crear EmployeeDetails.java en C: \> JUNIT_WORKSPACE, que es una clase POJO.

public class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;
   
   /**
   * @return the name
   */
	
   public String getName() {
      return name;
   }
	
   /**
   * @param name the name to set
   */
	
   public void setName(String name) {
      this.name = name;
   }
	
   /**
   * @return the monthlySalary
   */
	
   public double getMonthlySalary() {
      return monthlySalary;
   }
	
   /**
   * @param monthlySalary the monthlySalary to set
   */
	
   public void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }
	
   /**
   * @return the age
   */
   public int getAge() {
      return age;
   }
	
   /**
   * @param age the age to set
   */
   public void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails la clase se usa para -

  • obtener / establecer el valor del nombre del empleado.
  • obtener / establecer el valor del salario mensual del empleado.
  • obtener / establecer el valor de la edad del empleado.

Crea un archivo llamado EmpBusinessLogic.java en C: \> JUNIT_WORKSPACE, que contiene la lógica empresarial.

public class EmpBusinessLogic {
   // Calculate the yearly salary of employee
   public double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }
	
   // Calculate the appraisal amount of employee
   public double calculateAppraisal(EmployeeDetails employeeDetails) {
      double appraisal = 0;
		
      if(employeeDetails.getMonthlySalary() < 10000){
         appraisal = 500;
      }else{
         appraisal = 1000;
      }
		
      return appraisal;
   }
}

EmpBusinessLogic la clase se usa para calcular -

  • el salario anual de un empleado.
  • el monto de tasación de un empleado.

Crea un archivo llamado TestEmployeeDetails.java en C: \> JUNIT_WORKSPACE, que contiene los casos de prueba a probar.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   //test to check appraisal
   @Test
   public void testCalculateAppriasal() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      assertEquals(500, appraisal, 0.0);
   }

   // test to check yearly salary
   @Test
   public void testCalculateYearlySalary() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double salary = empBusinessLogic.calculateYearlySalary(employee);
      assertEquals(96000, salary, 0.0);
   }
}

TestEmployeeDetails La clase se utiliza para probar los métodos de EmpBusinessLogicclase. Eso

  • prueba el salario anual del empleado.
  • prueba el monto de tasación del empleado.

A continuación, cree un archivo de clase Java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestEmployeeDetails.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile el caso de prueba y las clases Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java 
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

true

Afirmación

Todas las aserciones están en la clase Assert.

public class Assert extends java.lang.Object

Esta clase proporciona un conjunto de métodos de afirmación, útiles para escribir pruebas. Solo se registran las afirmaciones fallidas. Algunos de los métodos importantes de la clase Assert son los siguientes:

No Señor. Métodos y descripción
1

void assertEquals(boolean expected, boolean actual)

Comprueba que dos primitivas / objetos sean iguales.

2

void assertTrue(boolean condition)

Comprueba que una condición sea verdadera.

3

void assertFalse(boolean condition)

Comprueba que una condición sea falsa.

4

void assertNotNull(Object object)

Comprueba que un objeto no sea nulo.

5

void assertNull(Object object)

Comprueba que un objeto sea nulo.

6

void assertSame(object1, object2)

El método assertSame () prueba si dos referencias de objeto apuntan al mismo objeto.

7

void assertNotSame(object1, object2)

El método assertNotSame () prueba si dos referencias de objeto no apuntan al mismo objeto.

8

void assertArrayEquals(expectedArray, resultArray);

El método assertArrayEquals () probará si dos matrices son iguales entre sí.

Usemos algunos de los métodos mencionados anteriormente en un ejemplo. Cree un archivo de clase java llamadoTestAssertions.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.*;

public class TestAssertions {

   @Test
   public void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
		
      int val1 = 5;
      int val2 = 6;

      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      assertEquals(str1, str2);

      //Check that a condition is true
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn't null
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      assertArrayEquals(expectedArray, resultArray);
   }
}

A continuación, cree un archivo de clase Java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner2 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestAssertions.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

true

Anotación

Las anotaciones son como metaetiquetas que puede agregar a su código y aplicarlas a métodos o en clase. Estas anotaciones en JUnit proporcionan la siguiente información sobre los métodos de prueba:

  • qué métodos se ejecutarán antes y después de los métodos de prueba.
  • qué métodos se ejecutan antes y después de todos los métodos, y.
  • qué métodos o clases se ignorarán durante la ejecución.

La siguiente tabla proporciona una lista de anotaciones y su significado en JUnit:

No Señor. Anotación y descripción
1

@Test

La anotación Test le dice a JUnit que el método public void al que está adjunto se puede ejecutar como un caso de prueba.

2

@Before

Varias pruebas necesitan objetos similares creados antes de que puedan ejecutarse. Anotar un método de vacío público con @Before hace que ese método se ejecute antes de cada método de prueba.

3

@After

Si asigna recursos externos en un método Before, debe liberarlos después de que se ejecute la prueba. Anotar un método de vacío público con @After hace que ese método se ejecute después del método de prueba.

4

@BeforeClass

Anotar un método void estático público con @BeforeClass hace que se ejecute una vez antes que cualquiera de los métodos de prueba de la clase.

5

@AfterClass

Esto ejecutará el método después de que hayan finalizado todas las pruebas. Esto se puede utilizar para realizar actividades de limpieza.

6

@Ignore

La anotación Ignorar se utiliza para ignorar la prueba y esa prueba no se ejecutará.

Cree un archivo de clase java llamado JunitAnnotation.java en C: \> JUNIT_WORKSPACE para probar la anotación.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

public class JunitAnnotation {
	
   //execute before class
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute after class
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute before test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute after test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case
   @Test
   public void test() {
      System.out.println("in test");
   }
	
   //test case ignore and will not execute
   @Ignore
   public void ignoreTest() {
      System.out.println("in ignore test");
   }
}

A continuación, cree un archivo de clase Java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar anotaciones.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(JunitAnnotation.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

in before class
in before
in test
in after
in after class
true

Este capítulo explica el procedimiento de ejecución de métodos en JUnit, que define el orden de los métodos llamados. A continuación se analiza el procedimiento de ejecución de los métodos de la API de prueba JUnit con example.

Cree un archivo de clase Java denominado ExecutionProcedureJunit.java en C: \> JUNIT_WORKSPACE para probar la anotación.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

public class ExecutionProcedureJunit {
	
   //execute only once, in the starting 
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute only once, in the end
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute for each test, before executing test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute for each test, after executing test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   //test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }
}

A continuación, cree un archivo de clase Java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar anotaciones.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(ExecutionProcedureJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class

Vea el resultado anterior. El procedimiento de ejecución es el siguiente:

  • En primer lugar, el método beforeClass () se ejecuta solo una vez.
  • El método afterClass () se ejecuta solo una vez.
  • El método before () se ejecuta para cada caso de prueba, pero antes de ejecutar el caso de prueba.
  • El método after () se ejecuta para cada caso de prueba, pero después de la ejecución del caso de prueba.
  • Entre antes () y después (), se ejecuta cada caso de prueba.

Los casos de prueba se ejecutan usando JUnitCoreclase. JUnitCore es una fachada para ejecutar pruebas. Admite la ejecución de pruebas JUnit 4, pruebas JUnit 3.8.x y mezclas. Para ejecutar pruebas desde la línea de comandos, ejecute java org.junit.runner.JUnitCore <TestClass>. Para ejecuciones de prueba de una sola vez, use el método estático runClasses (Class []).

A continuación se muestra la declaración de org.junit.runner.JUnitCore clase:

public class JUnitCore extends java.lang.Object

Aquí veremos cómo ejecutar las pruebas con la ayuda de JUnitCore.

Crear una clase

Cree una clase de Java para probar, digamos, MessageUtil.java, en C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
	
}

Crear clase de caso de prueba

  • Cree una clase de prueba de Java, por ejemplo, TestJunit.java.

  • Agregue un método de prueba testPrintMessage () a su clase de prueba.

  • Agregue una Annotaion @Test al método testPrintMessage ().

  • Implemente la condición de prueba y verifique la condición usando la API assertEquals de JUnit.

Cree un archivo de clase java llamado TestJunit.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Crear clase de corredor de pruebas

Ahora crea un archivo de clase java llamado TestRunner.javaen C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba. Importa la clase JUnitCore y usa el método runClasses () que toma el nombre de la clase de prueba como parámetro.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

Hello World
true

Test suitese utiliza para agrupar algunos casos de prueba unitarios y ejecutarlos juntos. En JUnit, ambos@RunWith y @Suitelas anotaciones se utilizan para ejecutar las pruebas de la suite. Este capítulo toma un ejemplo con dos clases de prueba,TestJunit1 Y TestJunit2, que se ejecutan juntos mediante Test Suite.

Crear una clase

Cree una clase de Java para probar, digamos, MessageUtil.java en C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Crear clases de casos de prueba

Cree un archivo de clase java llamado TestJunit1.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

Cree un archivo de clase java llamado TestJunit2.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Crear clase de suite de pruebas

  • Crea una clase de Java.
  • Adjunte la anotación @RunWith (Suite.class) con la clase.
  • Agregue una referencia a las clases de prueba JUnit usando la anotación @ Suite.SuiteClasses.

Cree un archivo de clase java llamado TestSuite.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({
   TestJunit1.class,
   TestJunit2.class
})

public class JunitTestSuite {   
}

Crear clase de corredor de pruebas

Cree un archivo de clase java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(JunitTestSuite.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile todas las clases de Java usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java 
TestJunit2.java JunitTestSuite.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true

A veces sucede que nuestro código no está completamente listo mientras se ejecuta un caso de prueba. Como resultado, el caso de prueba falla. los@Ignore la anotación ayuda en este escenario.

  • Un método de prueba anotado con @Ignore no se ejecutará.

  • Si una clase de prueba está anotada con @Ignore, no se ejecutará ninguno de sus métodos de prueba.

Ahora veamos a @Ignore en acción.

Crear una clase

Cree una clase de Java para probar, digamos, MessageUtil.java en C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
	
}

Crear clase de caso de prueba

  • Cree una clase de prueba de Java, por ejemplo, TestJunit.java.

  • Agregue un método de prueba testPrintMessage () o testSalutationMessage () a su clase de prueba.

  • Agregue una Annotaion @Ignore al método testPrintMessage ().

Cree un archivo de clase java llamado TestJunit.java en C: \ JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Ignore
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Crear clase de corredor de pruebas

Cree un archivo de clase java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases MessageUtil, Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Ahora ejecute Test Runner, que no ejecutará el caso de prueba testPrintMessage () definido en la clase Test Case proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida. El caso de prueba testPrintMessage () no se prueba.

Inside testSalutationMessage()
Hi!Robert
true

Ahora, actualice TestJunit en C: \> JUNIT_WORKSPACE para ignorar todos los casos de prueba. Agrega @Ignore a nivel de clase.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

@Ignore
public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
     
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Compile el caso de prueba usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit.java

Mantenga su Test Runner sin cambios de la siguiente manera:

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Ahora ejecute Test Runner, que no ejecutará ningún caso de prueba definido en la clase de Caso de prueba proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida. No se prueba ningún caso de prueba.

true

JUnit proporciona una práctica opción de tiempo de espera. Si un caso de prueba lleva más tiempo que el número especificado de milisegundos, JUnit lo marcará automáticamente como fallido. lostimeoutEl parámetro se usa junto con la anotación @Test. Veamos el @Test (tiempo de espera) en acción.

Crear una clase

Cree una clase de Java para probar, digamos, MessageUtil.java en C: \> JUNIT_WORKSPACE.

Agrega un bucle while infinito dentro del método printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      while(true);
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Crear clase de caso de prueba

Cree una clase de prueba de Java, digamos, TestJunit.java. Agregue un tiempo de espera de 1000 al caso de prueba testPrintMessage ().

Cree un archivo de clase java llamado TestJunit.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(timeout = 1000)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Crear clase de corredor de pruebas

Cree un archivo de clase java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases MessageUtil, Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará los casos de prueba definidos en la clase Test Case proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida. El caso de prueba testPrintMessage () marcará la prueba unitaria como fallida.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
testPrintMessage(TestJunit): test timed out after 1000 milliseconds
false

JUnit proporciona una opción para rastrear el manejo de excepciones del código. Puede probar si el código arroja una excepción deseada o no. losexpectedEl parámetro se usa junto con la anotación @Test. Veamos @Test (esperado) en acción.

Crear una clase

Cree una clase de Java para probar, digamos, MessageUtil.java en C: \> JUNIT_WORKSPACE.

Agregue una condición de error dentro del método printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      int a = 0;
      int b = 1/a;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Crear clase de caso de prueba

Crea una clase de prueba de Java llamada TestJunit.java. Agregue una excepción esperada ArithmeticException al caso de prueba testPrintMessage ().

Cree un archivo de clase java llamado TestJunit.java en C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(expected = ArithmeticException.class)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Crear clase de corredor de pruebas

Cree un archivo de clase java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases MessageUtil, Test case y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Ahora ejecute Test Runner, que ejecutará los casos de prueba definidos en la clase Test Case proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida. Se pasará el caso de prueba testPrintMessage ().

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
true

JUnit 4 ha introducido una nueva función llamada parameterized tests. Las pruebas parametrizadas permiten a un desarrollador ejecutar la misma prueba una y otra vez utilizando diferentes valores. Hay cinco pasos que debe seguir para crear una prueba parametrizada.

  • Anote la clase de prueba con @RunWith (Parameterized.class).

  • Cree un método estático público anotado con @Parameters que devuelva una colección de objetos (como matriz) como conjunto de datos de prueba.

  • Cree un constructor público que tome lo que es equivalente a una "fila" de datos de prueba.

  • Cree una variable de instancia para cada "columna" de datos de prueba.

  • Cree su (s) caso (s) de prueba utilizando las variables de instancia como fuente de los datos de prueba.

El caso de prueba se invocará una vez para cada fila de datos. Veamos las pruebas parametrizadas en acción.

Crear una clase

Cree una clase de Java para probar, digamos, PrimeNumberChecker.java en C: \> JUNIT_WORKSPACE.

public class PrimeNumberChecker {
   public Boolean validate(final Integer primeNumber) {
      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Crear clase de caso de prueba parametrizada

Cree una clase de prueba de Java, digamos, PrimeNumberCheckerTest.java. Cree un archivo de clase java llamadoPrimeNumberCheckerTest.java en C: \> JUNIT_WORKSPACE.

import java.util.Arrays;
import java.util.Collection;
 
import org.junit.Test;
import org.junit.Before;

import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
   private Integer inputNumber;
   private Boolean expectedResult;
   private PrimeNumberChecker primeNumberChecker;

   @Before
   public void initialize() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   // Each parameter should be placed as an argument here
   // Every time runner triggers, it will pass the arguments
   // from parameters we defined in primeNumbers() method
	
   public PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) {
      this.inputNumber = inputNumber;
      this.expectedResult = expectedResult;
   }

   @Parameterized.Parameters
   public static Collection primeNumbers() {
      return Arrays.asList(new Object[][] {
         { 2, true },
         { 6, false },
         { 19, true },
         { 22, false },
         { 23, true }
      });
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test
   public void testPrimeNumberChecker() {
      System.out.println("Parameterized Number is : " + inputNumber);
      assertEquals(expectedResult, 
      primeNumberChecker.validate(inputNumber));
   }
}

Crear clase de corredor de pruebas

Cree un archivo de clase java llamado TestRunner.java en C: \> JUNIT_WORKSPACE para ejecutar caso (s) de prueba.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(PrimeNumberCheckerTest.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile las clases PrimeNumberChecker, PrimeNumberCheckerTest y Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java
TestRunner.java

Ahora ejecute Test Runner, que ejecutará los casos de prueba definidos en la clase Test Case proporcionada.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique la salida.

Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
true

Tendremos un ejemplo para demostrar cómo ejecutar JUnit usando ANT. Siga los pasos que se indican a continuación.

Paso 1: Descarga Apache Ant

Descargue Apache Ant según el sistema operativo en el que esté trabajando.

SO Nombre de archivo
Ventanas apache-ant-1.8.4-bin.zip
Linux apache-ant-1.8.4-bin.tar.gz
Mac apache-ant-1.8.4-bin.tar.gz

Paso 2: Establecer el entorno de Ant

Selecciona el ANT_HOMEvariable de entorno para apuntar a la ubicación del directorio base, donde se almacenan las bibliotecas ANT en su máquina. Supongamos que las bibliotecas Ant están almacenadas en la carpeta apache-ant-1.8.4.

No Señor. SO y descripción
1

Windows

Establezca la variable de entorno ANT_HOME en C: \ Archivos de programa \ Apache Software Foundation \ apache-ant-1.8.4

2

Linux

exportar ANT_HOME = /usr/local/apache-ant-1.8.4

3

Mac

exportar ANT_HOME = /Library/apache-ant-1.8.4

Agregue la ubicación del compilador Ant a la ruta del sistema de la siguiente manera:

SO Salida
Ventanas Añade la cadena %ANT_HOME\bin al final de la variable del sistema, Path.
Linux export PATH = $PATH:$ANT_HOME / bin /
Mac no requerido

Paso 3: Descarga JUnit Archive

Descargue un archivo JUnit que se adapte a su sistema operativo.

SO Nombre de archivo
Ventanas junit4.10.jar
Linux junit4.10.jar
Mac junit4.10.jar

Paso 4: crear la estructura del proyecto

  • Crea una carpeta TestJunitWithAnt en C: \> JUNIT_WORKSPACE.

  • Crea una carpeta src en C: \> JUNIT_WORKSPACE> TestJunitWithAnt.

  • Crea una carpeta test en C: \> JUNIT_WORKSPACE> TestJunitWithAnt.

  • Crea una carpeta lib en C: \> JUNIT_WORKSPACE> TestJunitWithAnt.

  • Crear MessageUtil class en C: \> JUNIT_WORKSPACE> TestJunitWithAnt> srcfolder.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Crear TestMessageUtil class en la carpeta C: \> JUNIT_WORKSPACE> TestJunitWithAnt> src.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestMessageUtil {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Copie junit-4.10.jar en la carpeta C: \> JUNIT_WORKSPACE> TestJunitWithAnt> lib.

Crear ANT Build.xml

Estaremos usando <junit> tarea en Ant para ejecutar nuestros casos de prueba JUnit.

<project name = "JunitTest" default = "test" basedir = ".">
   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "full-compile" value = "true" />
	
   <path id = "classpath.base"/>
	
   <path id = "classpath.test">
      <pathelement location = "lib/junit-4.10.jar" />
      <pathelement location = "${testdir}" /> <pathelement location = "${srcdir}" />
      <path refid = "classpath.base" />
   </path>
	
   <target name = "clean" >
      <delete verbose = "${full-compile}"> <fileset dir = "${testdir}" includes = "**/*.class" />
      </delete>
   </target>
	
   <target name = "compile" depends = "clean">
      <javac srcdir = "${srcdir}" destdir = "${testdir}" 
         verbose = "${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>
	
   <target name = "test" depends = "compile">
      <junit>
         <classpath refid = "classpath.test" />
         <formatter type = "brief" usefile = "false" />
         <test name = "TestMessageUtil" />
      </junit>
   </target>
	
</project>

Ejecute el siguiente comando Ant.

C:\JUNIT_WORKSPACE\TestJunitWithAnt>ant

Verifique la salida.

Buildfile: C:\JUNIT_WORKSPACE\TestJunitWithAnt\build.xml

clean:  

compile:  
   [javac] Compiling 2 source files to C:\JUNIT_WORKSPACE\TestJunitWithAnt\test
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      MessageUtil.java]
   [javac] [parsing completed 18ms]
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      TestMessageUtil.java]
   [javac] [parsing completed 2ms]
   [javac] [search path for source files: C:\JUNIT_WORKSPACE\
      TestJunitWithAnt\src]    
   [javac] [loading java\lang\Object.class(java\lang:Object.class)]
   [javac] [loading java\lang\String.class(java\lang:String.class)]
   [javac] [loading org\junit\Test.class(org\junit:Test.class)]
   [javac] [loading org\junit\Ignore.class(org\junit:Ignore.class)]
   [javac] [loading org\junit\Assert.class(org\junit:Assert.class)]
   [javac] [loading java\lang\annotation\Retention.class
      (java\lang\annotation:Retention.class)]
   [javac] [loading java\lang\annotation\RetentionPolicy.class
      (java\lang\annotation:RetentionPolicy.class)]
   [javac] [loading java\lang\annotation\Target.class
      (java\lang\annotation:Target.class)]
   [javac] [loading java\lang\annotation\ElementType.class
      (java\lang\annotation:ElementType.class)]
   [javac] [loading java\lang\annotation\Annotation.class
      (java\lang\annotation:Annotation.class)]
   [javac] [checking MessageUtil]
   [javac] [loading java\lang\System.class(java\lang:System.class)]
   [javac] [loading java\io\PrintStream.class(java\io:PrintStream.class)]
   [javac] [loading java\io\FilterOutputStream.class
      (java\io:FilterOutputStream.class)]
   [javac] [loading java\io\OutputStream.class(java\io:OutputStream.class)]
   [javac] [loading java\lang\StringBuilder.class
      (java\lang:StringBuilder.class)]
   [javac] [loading java\lang\AbstractStringBuilder.class
      (java\lang:AbstractStringBuilder.class)]
   [javac] [loading java\lang\CharSequence.class(java\lang:CharSequence.class)]
   [javac] [loading java\io\Serializable.class(java\io:Serializable.class)]
   [javac] [loading java\lang\Comparable.class(java\lang:Comparable.class)]
   [javac] [loading java\lang\StringBuffer.class(java\lang:StringBuffer.class)]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\MessageUtil.class]
   [javac] [checking TestMessageUtil]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\TestMessageUtil.class]
   [javac] [total 281ms]

test:
    [junit] Testsuite: TestMessageUtil
    [junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec
    [junit]
    [junit] ------------- Standard Output ---------------
    [junit] Inside testPrintMessage()
    [junit] Robert
    [junit] Inside testSalutationMessage()
    [junit] Hi!Robert
    [junit] ------------- ---------------- ---------------

BUILD SUCCESSFUL
Total time: 0 seconds

Para configurar JUnit con eclipse, siga los pasos que se indican a continuación.

Paso 1: Descarga JUnit Archive

Descarga un jar JUnit basado en el sistema operativo que tienes en tu sistema.

SO Nombre de archivo
Ventanas junit4.10.jar
Linux junit4.10.jar
Mac junit4.10.jar

Suponga que ha copiado el archivo JAR anterior en la carpeta C: \> JUnit.

Paso 2: configurar el entorno de Eclipse

Abra eclipse → haga clic derecho en el proyecto y haga clic en propiedad> Ruta de compilación> Configurar ruta de compilación y agregue junit-4.10.jar en las bibliotecas usando el botón Agregar Jar externo.

Suponemos que su Eclipse tiene el complemento JUnit incorporado. Si no está disponible en el directorio C: \> eclipse \ plugins, puede descargarlo desdeJUnit Plugin. Descomprima el archivo zip descargado en la carpeta de complementos de Eclipse. Finalmente reinicie Eclipse.

Ahora su Eclipse está listo para el desarrollo de casos de prueba JUnit.

Paso 3: Verifique la instalación de JUnit en Eclipse

Crea un proyecto TestJuniten Eclipse en cualquier lugar. Entonces crea una claseMessageUtil para probar en el proyecto.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Crea una clase de prueba TestJunit en el proyecto.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {	  
      assertEquals(message,messageUtil.printMessage());
   }
}

Lo siguiente debe ser la estructura del proyecto:

Finalmente, haga clic derecho en el programa y ejecútelo como JUnit para verificar la salida del programa.

Verifica el resultado.

A continuación se muestran las extensiones JUnit:

  • Cactus
  • JWebUnit
  • XMLUnit
  • MockObject

Cactus

Cactus es un marco de prueba simple para pruebas unitarias de código java del lado del servidor (Servlets, EJB, Tag Libs, Filtros). La intención de Cactus es reducir el costo de escribir pruebas para el código del lado del servidor. Utiliza JUnit y lo amplía. Cactus implementa una estrategia en contenedor que ejecuta las pruebas dentro de un contenedor.

El ecosistema de cactus está formado por varios componentes:

  • Cactus Frameworkes el corazón de Cactus. Es el motor que proporciona la API para escribir pruebas de Cactus.

  • Cactus Integration Modules son interfaces y frameworks que proporcionan formas sencillas de utilizar Cactus Framework (scripts Ant, complemento Eclipse y complemento Maven).

El siguiente código demuestra cómo se puede utilizar Cactus.

import org.apache.cactus.*;
import junit.framework.*;

public class TestSampleServlet extends ServletTestCase {
   @Test
   public void testServlet() {
      // Initialize class to test
      SampleServlet servlet = new SampleServlet();

      // Set a variable in session as the doSomething()
      // method that we are testing 
      session.setAttribute("name", "value");

      // Call the method to test, passing an 
      // HttpServletRequest object (for example)
      String result = servlet.doSomething(request);

      // Perform verification that test was successful
      assertEquals("something", result);
      assertEquals("otherValue", session.getAttribute("otherName"));
   }
}

JWebUnit

JWebUnit es un marco de prueba basado en Java para aplicaciones web. Envuelve los marcos de prueba existentes, como HtmlUnit y Selenium, con una interfaz de prueba unificada y simple para probar la exactitud de sus aplicaciones web.

JWebUnit proporciona una API de Java de alto nivel para navegar por una aplicación web combinada con un conjunto de afirmaciones para verificar la exactitud de la aplicación. Esto incluye navegación a través de enlaces, ingreso y envío de formularios, validación del contenido de la tabla y otras características típicas de aplicaciones web comerciales.

Los métodos de navegación simples y las aserciones listas para usar permiten una creación de pruebas más rápida que usar solo JUnit o HtmlUnit. Y si desea cambiar de HtmlUnit a otros complementos como Selenium (disponible pronto), no es necesario que vuelva a escribir sus pruebas.

Aquí hay un código de muestra.

import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;

public class ExampleWebTestCase extends TestCase {
   private WebTester tester;
   
   public ExampleWebTestCase(String name) {
      super(name);
      tester = new WebTester();
   }
	
   //set base url
   public void setUp() throws Exception {
      getTestContext().setBaseUrl("http://myserver:8080/myapp");
   }
	
   // test base info
   @Test
   public void testInfoPage() {
      beginAt("/info.html");
   }
}

XMLUnit

XMLUnit proporciona una única clase de extensión JUnit, XMLTestCase, y un conjunto de clases de soporte que permiten hacer afirmaciones sobre:

  • Las diferencias entre dos piezas de XML (a través de las clases Diff y DetailDiff).

  • La validez de una pieza de XML (a través de la clase Validator).

  • El resultado de transformar un fragmento de XML usando XSLT (a través de la clase Transform).

  • La evaluación de una expresión XPath en un fragmento de XML (a través de clases que implementan la interfaz XpathEngine).

  • Nodos individuales en una pieza de XML que son expuestos por DOM Traversal (a través de la clase NodeTest).

Supongamos que tenemos dos piezas de XML que deseamos comparar y afirmar que son iguales. Podríamos escribir una clase de prueba simple como esta:

import org.custommonkey.xmlunit.XMLTestCase;

public class MyXMLTestCase extends XMLTestCase {

   // this test method compare two pieces of the XML
   @Test
   public void testForXMLEquality() throws Exception {
      String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
      String myTestXML = "<msg><localId>2376</localId></msg>";
      assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
   }
}

MockObject

En una prueba unitaria, los objetos simulados pueden simular el comportamiento de objetos complejos, reales (no simulados) y, por lo tanto, son útiles cuando un objeto real no es práctico o es imposible de incorporar a una prueba unitaria.

El estilo de codificación común para probar con objetos simulados es:

  • Crea instancias de objetos simulados.
  • Establezca el estado y las expectativas en los objetos simulados.
  • Invocar código de dominio con objetos simulados como parámetros.
  • Verifique la coherencia en los objetos simulados.

A continuación se muestra un ejemplo de MockObject usando Jmock.

import org.jmock.Mockery;
import org.jmock.Expectations;

class PubTest extends TestCase {
   Mockery context = new Mockery();
   public void testSubReceivesMessage() {
      // set up
      final Sub sub = context.mock(Sub.class);

      Pub pub = new Pub();
      pub.add(sub);
    
      final String message = "message";
      
      // expectations
      context.checking(new Expectations() {
         oneOf (sub).receive(message);
      });

      // execute
      pub.publish(message);
      
      // verify
      context.assertIsSatisfied();
   }
}