UD-03

11_JUnit_IDE

Diseño y realización de pruebas

JUnit en Eclipse
JUnit en NetBeans

Entornos de desarrollo – IES Pablo Serrano – DAM1D 1

 UD-03
11_JUnit_IDE

Contenido

1. JUnit en Eclipse ............................................................................................................ 3

1.1. Pruebas unitarias utilizando el IDE Eclipse ........................................................ 3
1.2. Carpeta tests ...................................................................................................... 3
1.3. ¿Qué probaremos? ............................................................................................ 4
1.4. Clase Suma ......................................................................................................... 4
1.5. Crear JUnit Test .................................................................................................. 5
1.5.1. Usar el asistente para crear la plantilla .................................................. 5
1.5.2. Completar el código................................................................................ 6
1.6. Ejecutar JUnit Test ............................................................................................. 7
1.7. Clase Calculadora ............................................................................................... 8
1.8. Probando excepciones ....................................................................................... 9
1.9. Testeos parametrizados ..................................................................................... 9
1.10. Fail ................................................................................................................ 10
1.11. Test suite ...................................................................................................... 10
1.12. Estructura final del proyecto ........................................................................ 12
2. JUnit en NetBeans ...................................................................................................... 13
2.1. Crear JUnit Test ................................................................................................ 13
2.2. Ejecutar JUnit Test ........................................................................................... 14
2.3. Test Suite.......................................................................................................... 15

Entornos de desarrollo – IES Pablo Serrano – DAM1D 2

 UD-03
11_JUnit_IDE

1. JUnit en Eclipse
Podemos escribir las pruebas JUnit manualmente, pero Eclipse apoya la creación de
pruebas JUnit mediante asistentes.

1.1. Pruebas unitarias utilizando el IDE Eclipse

Necesitamos crear un nuevo proyecto Eclipse o bien importar uno ya dado

que será nuestro caso.
Importaremos al workspace el proyecto llamado
Proyecto_Junit.
Si observas el código Java deducirás que hay un par de
paquetes con varias clases (bastantes inútiles, por cierto),
algunas con errores y otras sin ellos y además ninguna es
main del proyecto.
Pretendemos probarlas mediante pruebas unitarias sin
llegar a construir la aplicación entera, lo que hubiera sido
imposible si hubiésemos pretendido probarlas con el
depurador.

1.2. Carpeta tests

Una vez creado hay que crear una carpeta de código separada para los tests,
es una práctica habitual aunque no es necesario para su funcionamiento.
Pero la idea es tener el código del proyecto separado del código de los tests
unitarios.

Entornos de desarrollo – IES Pablo Serrano – DAM1D 3

 UD-03
11_JUnit_IDE

1.3. ¿Qué probaremos?

Lo ideal es escribir casos de prueba para cada método no trivial de cada clase
de la aplicación, de forma que cada caso sea independiente del resto.

1.4. Clase Suma

Tan simple e inútil que simplemente guarda dos variables que se podrán
sumar y restar. Tiene dos métodos, para poder hacer la prueba de meter dos
tests en una misma clase de JUnit.

package com.dam1d.proyecto_junit;

public class Suma {

private int num1;
private int num2;

public Suma(int n1, int n2) {

this.num1 = n1;
this.num2 = n2;
}

public int sumar() {

int resultado = num1 + num2;
return resultado;
}

public int resta() {

return num1 - num2;
}
}

Entornos de desarrollo – IES Pablo Serrano – DAM1D 4

 UD-03
11_JUnit_IDE

1.5. Crear JUnit Test

Vamos a crear una prueba para la clase Suma:

1.5.1. Usar el asistente para crear la plantilla

Menú contextual (click derecho) sobre la clase seleccionada: New [->Other-
>JUnit]->JUnit Test Case

Entornos de desarrollo – IES Pablo Serrano – DAM1D 5

 UD-03
11_JUnit_IDE

1.5.2. Completar el código

public class SumaTest {
public Suma suma;

@Before
public void setUp() throws Exception {
/**
* El metodo precedido por la etiqueta @Before
* es para indicar a JUnit que debe ejecutarlo
* antes de ejecutar los Tests que figuran en
* esta clase.
*/
this.suma = new Suma(3, 5);
}

@After
public void tearDown() throws Exception {
/**
* La etiqueta @After es la antítesis de @Before.
* Simplemente este metodo se ejecutara después de
* ejecutar todos los tests de esta clase.
*/
// en este caso no hago nada, solo está de ejemplo
}

@Test
public void testSumar() {
/**
* La etiqueta @Test indica que es método de prueba
*/
int resultado = this.suma.sumar();
// con esto verificamos que el resultado es el esperado
assertTrue(resultado == 8);
}

@Test
public void testResta() {
int resultado = this.suma.resta();
assertTrue(resultado == -2);
}

Guardamos el código naturalmente!

Entornos de desarrollo – IES Pablo Serrano – DAM1D 6

 UD-03
11_JUnit_IDE

1.6. Ejecutar JUnit Test

Botón dcho sobre la clase JUnit Test:

Y se abre la vista JUnit:

Que muestra que la clase Suma ha pasado el caso de prueba de sumar y restar
los números 3 y 5. !
Se anota el resultado exitoso de la prueba en la hoja de casos de pruebas.

Entornos de desarrollo – IES Pablo Serrano – DAM1D 7

 UD-03
11_JUnit_IDE

1.7. Clase Calculadora

Al observar el código, deducimos que tiene dos métodos que permiten sumar
y multiplicar un conjunto de números, pero quizás no están bien
desarrollados.
Creamos su JUnit Test correspondiente que podría ser:
public class CalculadoraTest {
public Calculadora calc;
@Before
public void setUp() throws Exception {
calc = new Calculadora();
}
@Test
public void testSuma() {
assertEquals("Error en suma", 60, calc.suma(10, 20, 30));

} Valor esperado: calculado “manualmente” al Valor obtenido:

preparar los casos de pruebas Se calculará usando el código
@Test
public void testMultiplica() {
assertEquals("Error en multip", 6000, calc.multiplica(10, 20, 30));
}
}

Al ejecutar, dado que tiene errores, aparecen en la vista JUnit:

Se anota el resultado de la prueba en la hoja de casos de pruebas para que el

desarrollador revise el código (utilizando por ejemplo el depurador) y lo
corrija.

Entornos de desarrollo – IES Pablo Serrano – DAM1D 8

 UD-03
11_JUnit_IDE

1.8. Probando excepciones

La clase MiClase puede servirnos para probar pruebas unitarias de

excepciones ya que vemos que multiplica (¡?) cuando el primer operador es
menor que 999, en caso contrario lanza una excepción.
El código de su JUnit podría ser semejante a este:
public class MiClaseTest {
@Test(expected = IllegalArgumentException.class)
public void testExceptionIsThrown() {
MiClase tester = new MiClase();
tester.multiply(1000, 5);
}
@Test
public void testMultiply() {
MiClase tester = new MiClase();
assertEquals("10 x 5 debe ser 50", 50, tester.multiply(10, 5));
}
}
¿Prueba exitosa?

1.9. Testeos parametrizados

En el caso anterior hemos probado el caso de prueba (10,5) del método

multiply de la clase MiClase. Ahora queremos probar el mismo método de la
misma clase pero para varios casos de prueba (1,1), (5,8) y (121,0).
No es necesario repetir las pruebas para cada uno de los casos, nos basta con
parametrizar.
El código de su JUnit podría ser semejante a este:
@RunWith(Parameterized.class)
public class MiClaseTestConParametros {
private int multiplicando, multiplicador;
public MiClaseTestConParametros(int testParameter1,int testParameter2) {
this.multiplicando = testParameter1;
this.multiplicador = testParameter2;
}
// creamos los datos del test
@Parameters
public static Collection<Object[]> data() {
Object[][] data = new Object[][] { { 1, 1 }, { 5,8 }, { 121,0 } };
return Arrays.asList(data);
}
@Test
public void testMultiply() {
MiClase tester = new MiClase();
assertEquals("Result", multiplicando * multiplicador,
tester.multiply(multiplicando, multiplicador));
}
}
¿Es lo mismo error que failure?

Entornos de desarrollo – IES Pablo Serrano – DAM1D 9

 UD-03
11_JUnit_IDE

1.10. Fail
Prueba el siguiente JUnit Test para la clase Multiplicación para comprobar que
hace el método fail de la clase Assert:
public class MultiplicacionTest {
@Before
public void setUp() throws Exception {
System.out.println("Hola!");
}
@Test
public void testMultiplicar() {
fail("Sin hacer");
}
}

Añádele la anotación
@Ignore("No quiero que haga el siguiente test")
delante de la anotación @Test

Observa el icono que aparece en la vista JUnit.

1.11. Test suite

Crea el JUnit Test para la clase Division de la siguiente manera:

public class DivisionTest {
private Division divi;
@Before
public void setUp() throws Exception {
divi=new Division(8, 0);
}
@Test
public void testDivide() {
assertEquals ("Bien",(int)2,divi.divide());
}
}
No la ejecutes todavía.
Tenemos varios JUnit Test, ejecutarlos individualmente puede ser una tarea
tediosa, vamos a probar todos los JUnit Test conjuntamente.
Como no todos los JUnit Test están en el mismo paquete, primero debemos
agrupar por paquetes y luego conseguir el conjunto:

Entornos de desarrollo – IES Pablo Serrano – DAM1D 10

 UD-03
11_JUnit_IDE

Para ello primero agruparemos los del paquete com.dam1.proyecto_junit de

la siguiente manera:

El JUnit Test resultante simplemente necesitará de la declaración de la clase,

que no tendrá nada dentro. Esta clase estará marcada por dos etiquetas
 RunWith que le indicará con que clase del framework debe cargar esta
clase
 SuiteClasses que tendrá una lista de las clases que son Tests o
SuiteClasses (esto implica que podemos meter SuiteClasses dentro de
SuiteClasses y así poder organizar jerárquicamente los tests):

@RunWith(Suite.class)
@SuiteClasses({ CalculadoraTest.class, MiClaseTest.class,
MiClaseTestConParametros.class, MultiplicacionTest.class,
SumaTest.class })
public class AllTests {

Para poder añadir el JUnit Test que nos falta del otro paquete realizaremos
una clase “suite test” en la raíz de la carpeta tests. Para ejecutar todos los
tests conjuntamente, esta se llamará AllTestsDeTodosLosPaquetes.
El asistente solo nos crea:
@RunWith(Suite.class)
@SuiteClasses({})
public class AllTestsDeTodosLosPaquetes {

Debemos añadir en la anotación @SuiteClasses las clases de test que nos

interesan:
@SuiteClasses({AllTests.class,DivisionTest.class})

Vemos que en el SuiteClasses podemos mezclar Tests simples y TestSuite.

Entornos de desarrollo – IES Pablo Serrano – DAM1D 11

 UD-03
11_JUnit_IDE

Ya tenemos nuestros tests preparados para ejecutar por lote. Vamos ahora a
pulsar botón derecho en AllTestsDeTodosLosPaquetes y seleccionar Run as
JUnit Test. Automáticamente el Eclipse lanzará todos los tests que tenemos
programados y nos aparecerá un resultado parecido a esto:

¿Qué otra manera se te ocurre que podríamos haber utilizado para incluir el
test que nos faltaba?

1.12. Estructura final del proyecto

Entornos de desarrollo – IES Pablo Serrano – DAM1D 12

 UD-03
11_JUnit_IDE

2. JUnit en NetBeans
Utilizar JUnit en NetBeans también es muy sencillo

2.1. Crear JUnit Test

Dada una clase a lo que queremos hacer JUnit Test, se selecciona en la lista de
clases, click derecho:

Y se genera la plantilla sobre la que trabajar.

Entornos de desarrollo – IES Pablo Serrano – DAM1D 13

 UD-03
11_JUnit_IDE

2.2. Ejecutar JUnit Test

Seleccionada la clase JUnit, click derecho:

Y aparece la ventana de resultados del test:

Entornos de desarrollo – IES Pablo Serrano – DAM1D 14

 UD-03
11_JUnit_IDE

2.3. Test Suite

Entornos de desarrollo – IES Pablo Serrano – DAM1D 15