Introducción a JUnit – (Video)


JUnit es un framework que se utiliza en programación para hacer pruebas unitarias en aplicaciones desarrolladas en Java.

Es habitual en el desarrollo software definir un buen plan de pruebas antes de la fase de implementación (bien en la fase de análisis o diseño) para comprobar que el código desarrollado funciona correctamente y que se ajusta a los requisitos y especificaciones definidas para el producto software que se pretende desarrollar.

En este Video-Tutorial se realizaran una serie de pruebas unitarias a un código previamente desarrollado con el fin de mostrar el framework y ver algunas de sus utilidades.

El código sobre el que se realizaran las pruebas unitarias es una clase que representa a un numero complejo y que realiza las operaciones de suma, resta, multiplicación, división y módulo, a parte de tener otros métodos “llamados absurdos” y creados para este tutorial con fines didácticos.

El proyecto de este Video-Tutorial lo podéis descargar AQUÍ.

A continuación se muestra una tabla, a modo de resumen de las comprobaciones que se pueden hacer con JUnit:

Método assertxxx() de JUnit Qué comprueba
assertTrue(expresión) comprueba que expresión evalúe a true
assertFalse(expresión) comprueba que expresión evalúe a false
assertEquals(esperado,real) comprueba que esperado sea igual a real
assertNull(objeto) comprueba que objeto sea null
assertNotNull(objeto) comprueba que objeto no sea null
assertSame(objeto_esperado,objeto_real) comprueba que objeto_esperado y objeto_real sean el
mismo objeto
assertNotSame(objeto_esperado,objeto_real) comprueba que objeto_esperado no sea el mismo objeto
que objeto_real
fail() hace que el test termine con fallo

Enlace al Jdoc de JUnit: http://www.dc.fi.udc.es/ai/tp/practica/junit/javadoc/junit/framework/Assert.html

Código sobre el que se realizaran las pruebas:

package Main;
public class NumComplejo {

	private double pReal;
	private double pImaginaria;

	public NumComplejo(){

	}

	public NumComplejo(double pReal, double pImaginaria){
		this.pReal=pReal;
		this.pImaginaria=pImaginaria;
	}

	public double getpReal() {
		return pReal;
	}

	public void setpReal(double pReal) {
		this.pReal = pReal;
	}

	public double getpImaginaria() {
		return pImaginaria;
	}

	public void setpImaginaria(double pImaginaria) {
		this.pImaginaria = pImaginaria;
	}

	/**
	 * Suma dos numeros complejos
	 * @param c1
	 * @param c2
	 * @return suma
	 */
	public NumComplejo sumarComplejos (NumComplejo c1, NumComplejo c2){
		NumComplejo result = new NumComplejo();

		result.setpReal(c1.getpReal()+c2.getpReal());
		result.setpImaginaria(c1.getpImaginaria()+c2.getpImaginaria());

		return result;
	}

	/**
	 * Resta dos numeros complejos
	 * @param c1
	 * @param c2
	 * @return resta
	 */
	public NumComplejo restarComplejos (NumComplejo c1, NumComplejo c2){
		NumComplejo result = new NumComplejo();

		result.setpReal(c1.getpReal()-c2.getpReal());
		result.setpImaginaria(c1.getpImaginaria()-c2.getpImaginaria());

		return result;
	}

	/**
	 * Multiplica dos numeros complejos
	 * @param c1
	 * @param c2
	 * @return multiplicacion
	 */
	public NumComplejo multiplicarComplejos (NumComplejo c1, NumComplejo c2){
		NumComplejo result = new NumComplejo();

		double a=c1.getpReal();
		double b=c1.getpImaginaria();
		double c=c2.getpReal();
		double d=c2.getpImaginaria();

		result.setpReal((a*c)-(b*d));
		result.setpImaginaria((a*d)+(b*c));

		return result;
	}

	/**
	 * Divide dos numeros complejos
	 * @param c1
	 * @param c2
	 * @return division
	 */
	public NumComplejo dividirComplejos (NumComplejo c1, NumComplejo c2){
		NumComplejo result = new NumComplejo();

		double a=c1.getpReal();
		double b=c1.getpImaginaria();
		double c=c2.getpReal();
		double d=c2.getpImaginaria();

		double dividendoReal = (a*c)+(b*d);
		double dividendoImaginario = (b*c)-(a*d);
		double divisor = (Math.pow(c, 2)+Math.pow(d, 2));

		result.setpReal(dividendoReal/divisor);
		result.setpImaginaria(dividendoImaginario/divisor);

		return result;
	}

	/**
	 * Calcula el modulo de un numero complejo
	 * @param numComplejo
	 * @return modulo
	 */
	public double modulo (NumComplejo numComplejo){
		double real =  numComplejo.getpReal();
		double imaginaria = numComplejo.getpImaginaria();

		return Math.sqrt(Math.pow(real, 2)+Math.pow(imaginaria, 2));
	}

	@Override
	public String toString(){
		if (pImaginaria>=0){
			return pReal+"+"+pImaginaria+"i";
		}else
			return pReal+"-"+(pImaginaria*(-1))+"i";
	}

	/**********************************************************************/
	/****** Métodos absurdos para poder mostrar un ejemplo con Junit ******/
	/**********************************************************************/
	// Método que te devuelve true si el numero que se le pasa es positivo
	// o false si es negativo
	public boolean esPositivo(double num){
		if(num>0)
			return true;
			else
				return false;
	}

	/**
	 * Método Absurso que devuelve un array
	 * @param c1
	 * @return
	 */
	public double [] getUnArray (NumComplejo c1){
		double [] nums = new double [2];
		nums[0]=c1.getpReal();
		nums[1]=c1.getpImaginaria();
		return nums;
	}

	/**
	 * OTRO Método Absurso que devuelve un array de tamaño 2 sumando 1 al primer elemento
	 * @param c1
	 * @return
	 */
	public double [] getOtroArray (double [] array){
		array[0] ++;
		return array;
	}

	/**
	 * Método absurdo que tarda 2 segundos en dar el resultado
	 * @return
	 * @throws InterruptedException
	 */
	public int time () throws InterruptedException{
		Thread.sleep(4000);
		return 1;
	}

}

Implementación de las pruebas:

package Main;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class pruebasUnitarias {

	private NumComplejo c1;
	private NumComplejo c2 = new NumComplejo(1,1);
	private double [] nums = {1,0};
	private double [] nums2 = null;

	/**
	 * Este método se ejecuta antes de hacer cualquier comprbación
	 */
	@Before
	public void antesQue(){
		c1 = new NumComplejo(1,0);
	}

	/**
	 * Comprueba el método "sumarComplejos"
	 */
	@Test
	public void sumaTest(){
		c1 = c1.sumarComplejos(c1, c2);
		assertEquals(2.0, c1.getpReal(),0);
		assertEquals(1.0, c1.getpImaginaria(),0);
	}

	/**
	 * Comprueba el método "restarComplejos"
	 */
	@Test
	public void restaTest() {
		c1 = c1.restarComplejos(c1, c2);
		assertEquals(0.0, c1.getpReal(),0);
		assertEquals(-1.0, c1.getpImaginaria(),0);
	}

	/**
	 * Comprueba el método "multiplicarComplejos"
	 */
	@Test
	public void multiplicaciónTest() {
		c1 = c1.multiplicarComplejos(c1, c2);
		System.out.println("Resultado de la multiplicación: "+c1.toString());
		assertEquals(1.0, c1.getpReal(),0);
		assertEquals(1.0, c1.getpImaginaria(),0);
	}

	/**
	 * Comprueba el método "dividirComplejos"
	 */
	@Test
	public void divisionTest() {
		c1 = c1.dividirComplejos(c1, c2);
		System.out.println("Resultado de la división: "+c1.toString());
		assertEquals(0.5, c1.getpReal(),0);
		assertEquals(-0.5, c1.getpImaginaria(),0);
	}

	/**
	 * Comprueba el método "modulo"
	 */
	@Test
	public void moduloTest() {
		double modulo = c2.modulo(c2);
		System.out.println("Modulo: "+modulo);
		assertEquals(Math.sqrt(2),c2.modulo(c2),0);

	}

	/**
	 * Comprueba si dos arrays son iguales
	 */
	@Test
	public void array(){
		assertArrayEquals(nums, c1.getUnArray(c1), 0);
	}

	/**
	 * Comprueba si el resultado es TRUE
	 */
	@Test
	public void esTrue(){
		assertTrue(c1.esPositivo(c1.getpReal()));
	}

	/**
	 * Comprueba si el resultado del método es FALSE
	 */
	@Test
	public void esFalse(){
		assertFalse(c1.esPositivo(c1.getpImaginaria()));
	}

	/**
	 * Comprueba si el parametro es nulo
	 */
	@Test
	public void esNull(){
		assertNull(nums2);
	}

	/**
	 * Comprueba si los objetos son los mismos
	 */
	@Test
	public void theSame(){
		System.out.println("Array antes de modificarse: "+nums[0]+"  "+nums[1]);
		c1.getOtroArray(nums);
		assertSame(nums, nums);
		System.out.println("Array despues de modificarse: "+nums[0]+"  "+nums[1]);
	}

	/**
	 * Comprueba si los objetos son distintos
	 */
	@Test
	public void noTheSame(){
		assertNotSame(c1, c2);
	}

	/**
	 * Comprueba que el método tarda en ejecutarse menos de 5 segundos
	 * @throws InterruptedException
	 */
	@Test (timeout=5000)
	public void time () throws InterruptedException{
		int i = c1.time();
	}

}
Comparte esta entrada en:
Safe Creative #1401310112503
Introducción a JUnit – (Video) por "www.jarroba.com" esta bajo una licencia Creative Commons
Reconocimiento-NoComercial-CompartirIgual 3.0 Unported License.
Creado a partir de la obra en www.jarroba.com

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies

ACEPTAR
Aviso de cookies