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.javaAhora ejecute Test Runner para ver el resultado de la siguiente manera:
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
trueJUnit 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
Hello World
trueAhora 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 TestRunnerVerifique la salida.
Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
falseEl 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.ObjectEsta 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunner1Verifique la salida.
trueClase TestCase
A continuación se muestra la declaración de org.junit.TestCase clase -
public abstract class TestCase extends Assert implements TestUn 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunner2Verifique la salida.
No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
trueClase TestResult
A continuación se muestra la declaración de org.junit.TestResult clase -
public class TestResult extends ObjectUn 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunner3Verifique la salida.
trueClase TestSuite
A continuación se muestra la declaración de org.junit.TestSuite clase:
public class TestSuite extends Object implements TestUn 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.javaAhora ejecute Test Suite.
C:\JUNIT_WORKSPACE>java JunitTestSuiteVerifique la salida.
No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3Aquí 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
trueAfirmación
Todas las aserciones están en la clase Assert.
public class Assert extends java.lang.ObjectEsta 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
trueAnotació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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
in before class
in before
in test
in after
in after class
trueEste 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after classVea 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.ObjectAquí 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
Hello World
trueTest 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.javaAhora ejecute Test Runner, que ejecutará el caso de prueba definido en la clase de Caso de prueba proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
trueA 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.javaAhora ejecute Test Runner, que no ejecutará el caso de prueba testPrintMessage () definido en la clase Test Case proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida. El caso de prueba testPrintMessage () no se prueba.
Inside testSalutationMessage()
Hi!Robert
trueAhora, 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.javaMantenga 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 TestRunnerVerifique la salida. No se prueba ningún caso de prueba.
trueJUnit 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.javaAhora ejecute Test Runner, que ejecutará los casos de prueba definidos en la clase Test Case proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique 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
falseJUnit 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.javaAhora ejecute Test Runner, que ejecutará los casos de prueba definidos en la clase Test Case proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida. Se pasará el caso de prueba testPrintMessage ().
Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
trueJUnit 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.javaAhora ejecute Test Runner, que ejecutará los casos de prueba definidos en la clase Test Case proporcionada.
C:\JUNIT_WORKSPACE>java TestRunnerVerifique la salida.
Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
trueTendremos 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>antVerifique 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 secondsPara 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();
}
}