Hola a todos, hoy os explicare como podemos realizar una aplicación para probar nuestra clase en Java.
Lo primero que haremos es añadir JUnit a nuestro IDE:
Cuando creemos la aplicación esto es lo que veremos.
import static org.junit.Assert.*;
import org.junit.Test;
public class PruebaTest {
@Test
public void test() {
fail("Not yet implemented");
}
}
Antes de hacer nada con la aplicación, vamos a crear una clase para comprobar que sus métodos funcionan como queremos.
/**
* Clase Empleado
*
* Contiene informacion de cada empleado
*
* @author Fernando
* @version 1.0
*/
public class Empleado{
//Constantes
/**
* Constante SALARIO_DEF
*/
public final static double SALARIO_DEF=600;
/**
* Indica que la edad de un empleado es mayor que otro
*/
public final static int MAYOR=1;
/**
* Indica que las edades de los empleados son iguales
*/
public final static int IGUAL=0;
/**
* Indica que la edad de un empleado es menor que otro
*/
public final static int MENOR=-1;
//Atributos
/**
* Nombre del empleado
*/
private String nombre;
/**
* Apellido del empleado
*/
private String apellido;
/**
* Edad del empleado
*/
private int edad;
/**
* Salario del empleado
*/
private double salario;
//Metodos publicos
/**
* Devuelve el nombre del empleado
* @return nombre del empleado
*/
public String getNombre() {
return nombre;
}
/**
* Devuelve el apellido del empleado
* @return apellido del empleado
*/
public String getApellido() {
return apellido;
}
/**
* Devuelve la edad de un empleado
* @return edad del empleado
*/
public int getEdad() {
return edad;
}
/**
* Devuelve el salarioBase
* @return salarioBse
*/
public double getSalario() {
return salario;
}
/**
* Suma un plus si el empleado tiene mas de 40 años
* @param sueldoPlus
* @return true si se realiza y false si no se realiza
*/
public boolean plus (double sueldoPlus){
boolean aumento=false;
if (edad>40){
salario+=sueldoPlus;
aumento=true;
}
return aumento;
}
/**
* Indica si dos empleados son iguales segun su nombre y apellido
* @param a empleado a comparar
* @return true si son iguales y false si no lo son
*/
public boolean equals (Empleado a){
if(a.getNombre().equals(nombre) && a.getApellido().equals(apellido)){
return true;
}else{
return false;
}
}
/**
* Indica si un empleado es mayor, igual o menor que otro segun la edad
* @param a empleado a comparar
* @return 1: mayor, 0: iguales y -1 menor que el empleado comparado
*/
public int compareTo(Empleado a){
int estado=MENOR;
if(this.edad==a.getEdad()){
//Los objetos son iguales
estado=IGUAL;
}else if(this.edad>a.getEdad()){
//El objeto 1 es mayor que la pasada por parametro
estado=MAYOR;
}
return estado;
}
/**
* Devuelve el estado del empleado
* @return estado del empleado
*/
public String toString (){
String mensaje="El empleado se llama "+nombre+" "+apellido+" con "+edad+" años " +
"y un salario de "+salario;
return mensaje;
}
//Constructores
/**
* Constructor por defecto
*/
public Empleado(){
this ("", "", 0, SALARIO_DEF);
}
/**
* Constructor con 2 parametros
* @param nombre nombre del empleado
* @param apellido nombre del empleado
*/
public Empleado(String nombre, String apellido){
this (nombre, apellido, 0, SALARIO_DEF);
}
/**
* Constructor con 3 parametros
* @param nombre nombre del empleado
* @param apellido nombre del empleado
* @param edad edad del empleado
*/
public Empleado (String nombre, String apellido, int edad){
this (nombre, apellido, edad, SALARIO_DEF);
}
/**
* Constructor con 4 parametros
* @param nombre nombre del empleado
* @param apellido nombre del empleado
* @param edad edad del empleado
* @param salario salario del empleado
*/
public Empleado(String nombre, String apellido, int edad, double salario){
this.nombre=nombre;
this.apellido=apellido;
this.edad=edad;
this.salario=salario;
}
}
Ahora volvemos a nuestra aplicación de Test, vemos que al principio del método tenemos @Test esto es una anotación Junit, tenemos varias:
- @BeforeClass: Sólo puede haber un método con este marcador, es invocado una vez al principio de todas los test. Se suele usar para inicializar atributos.
- @AfterClass: Sólo puede haber un método con este marcador y se invoca al finalizar todas los test.
- @Before: Se ejecuta antes de de cada test.
- @After: Se ejecuta después de cada test.
- @Ignore: Los métodos marcados con esta anotación no serán ejecutados.
- @Test: Representa un test que se debe ejecutar. También podemos hacer lo siguiente: @Test (timeout=X) el test será válido si se ejecuta antes de X milisegundos.
La que mas usaremos sera BeforeClass y Test, pero siempre nos puede venir venir bien usar alguna de las anotaciones anteriores.
Ahora vamos a ver los métodos que usaremos, disponibles en JUnit, todos se invocan con la clase Assert de forma estático. Los mas usados son:
- assertEquals(resultado esperado, resultado actual): le pasamos el resultado que nosotros esperamos y invocamos la función que estamos testando.
- assertNull(objeto): si un objeto es null el test sera exitoso.
- assertNotNull(objeto): al contrario que el anterior.
- assertTrue(condición): si la condición pasada (puede ser una función que devuelva un booleano) es verdadera el test sera exitoso.
- assertFalse(condición): si la condición pasada (puede ser una función que devuelva un booleano) es falsa el test sera exitoso.
- assertSame(Objeto1, objeto2): compara las referencias de los objetos.
- assertNotSame(Objeto1, objeto2): al contrario que el anterior.
Veamos un ejemplo:
import static org.junit.Assert.*;
import junit.framework.Assert;
import org.junit.*;
public class PruebaTest {
/*
* Definimos objetos de tipo empleado
* para usarlos en todos los tests
*/
static Empleado empleado1;
static Empleado empleado2;
static Empleado empleado3;
static Empleado empleado4;
//Este método se invoca el primero antes de nada
@BeforeClass
public void inicio() {
//Creamos los objetos
empleado1=new Empleado("Fernando", "Ureña", 23, 1000);
empleado2=new Empleado("Antonio", "Lopez", 23, 800);
empleado3=new Empleado();
empleado4=new Empleado("Fernando", "Ureña", 43, 1200);
}
@Test
public void plusTest(){
double plus=50;
//Devolvera falso ya que tiene menos de 40 años
Assert.assertEquals(false, empleado1.plus(plus));
//Devolvera falso ya que tiene menos de 40 años
Assert.assertEquals(false, empleado2.plus(plus));
//Devolvera falso ya que tiene menos de 40 años
Assert.assertEquals(false, empleado3.plus(plus));
//Devolvera verdadero ya que tiene mas de 40 años
Assert.assertEquals(true, empleado4.plus(plus));
}
@Test
public void equalsTest(){
//Comprobamos si son iguales unos empleados de otro
//Devolvera false ya que su nombre y apellido son distintos
Assert.assertEquals(false, empleado1.equals(empleado2));
//Devolvera false ya que su nombre y apellido son distintos
Assert.assertEquals(false, empleado2.equals(empleado3));
//Devolvera true ya que su nombre y apellido son diguales
Assert.assertEquals(true, empleado1.equals(empleado4));
}
@Test
public void compareTo(){
//Comparamos entre distintos empleados, usamos constantes
//Los dos empleados tienen la misma edad
Assert.assertEquals(Empleado.IGUAL, empleado1.compareTo(empleado2));
//El empleado 4 es mayor que el empleado 1
Assert.assertEquals(Empleado.MAYOR, empleado4.compareTo(empleado1));
//El empleado es mayor que el empleado 1
Assert.assertEquals(Empleado.MENOR, empleado3.compareTo(empleado2));
}
}
Cuando ejecutemos la aplicación, nos aparecerá a la izquierda el resultado, indicándonos que Test ha sido exitoso y cual no, diciéndonos en que línea estaría el error.
Es posible que al escribir el código, veas que aparece subrayado en amarillo, es porque está deprecated, pero funcionara, no os preocupéis.
Con netbeans, es igual. Recordad que se os crea en el paquete test. Para ver los resultados, tenéis que pinchar en la clase del test que hemos creado y pulsamos Test File.
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Deja una respuesta