Taller

En Parejas
Ejercicio:
• Deben seleccionar una clase de un código elaborado por ustedes en semestres
anteriores (en Java). Deben ser una clase “compleja” (no pueden ser una clase
que tenga solo constructores y métodos set y get).
• Se debe realizar la revisión de la clase seleccionada, usando la lista de
chequeo del código.
• Deben seleccionar el método más “complejo” de la clase seleccionada y para
dicho método deben diseñar y escribir tres pruebas unitarias.

Nota: NO es necesario hacer correcciones o cambios en el código en caso de

encontrar errores.

Se debe entregar un solo documento (del cual se encuentra el formato en las

siguientes páginas) con:
• El código de la clase seleccionada.
• La lista de chequeo del código diligenciada.
• El código del método seleccionado.
• La tabla con los casos de prueba (descripción, entradas y resultados
esperados).
• El código de las pruebas usando JUnit.
• Un pantallazo con los resultados de ejecución de estas pruebas
• Una apreciación final sobre la calidad de la clase que seleccionaron,
considerando los resultados obtenidos en las actividades realizadas.

Taller.
Integrantes:

-Jose Manuel Araujo Orrego

- Oscar Andrés Diaz Castaño

Clase seleccionada:

Aquí va el código de la clase seleccionada.

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;
}

Lista de chequeo de la clase seleccionada:

Categoría: Sintaxis
Pregunta Rpta Observaciones
.
Sólo se tiene una instrucción por línea si cada instrucción se
encuentra en una línea
diferente
Los identificadores son significativos y siguen los si el codigo tiene los
lineamientos recomendados para el lenguaje lineamientos de
acuerdo al lenguaje en
el que se escribió.
 Los bloques de código tienen la sangría si cada llave y paréntesis
(“identación”) definida y las llaves que cierran están abre y cierra donde se
alineadas con la instrucción que comienza el debe
bloque.
Cada condicional y ciclo tiene el bloque de código si todos los ciclos abren y
demarcado (llaves) cierran las llaves

Categoría: Semántica
Pregunta Rpta Observaciones
.
Cada ciclo tiene una condición de finalización si todas las condiciones
correcta están bien elaboradas
Todos los atributos y las variables tienen un valor no no tiene variable
inicial adecuado para su función inicializada
El uso de >, >=, <, <=, II, && corresponde a lo si cuenta con los signos
requerido correctos
Se verifican los valores de los parámetros antes de no está verificando las
realizar operaciones con ellos variables
El orden en el cual se pasan los parámetros si todos corresponde al
corresponde al orden en la definición del método orden en el que van
El nombre del método es coherente con la función si el nombre corresponde
que realiza a la función que se va a
realizar
Se manejan adecuadamente las excepciones: no cuenta con excepciones
• No hay excepciones silenciosas (es decir, del codigo
con el “catch” vacío)
• Los mensajes al usuario son claros y
acordes con el error
Los atributos tienen el tipo de dato y la visibilidad si todos los datos
adecuados para cumplir con lo requerido cumplen con la función
de visibilidad
Los métodos tienen los parámetros, tipos de retorno si todos cumplen con
y visibilidad adecuados para cumplir con su función estos reglamentos

Categoría: Documentación
Pregunta Rpta Observaciones
.
Cada clase está documentada tal ya que solo esta
vez documentada alguna
parte del codigo
Cada método está documentado si algunos métodos están
documentados
La documentación es clara y suficiente. si solo lo necesario para
estar clara

Código del método seleccionado:

Aquí va el código del método.

/**
* 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);
}

Diseño de casos de prueba para el método seleccionado:

Descripción Entradas Resultados esperados

Código de las pruebas en JUnit para el método seleccionado:

Aquí va el código de la clase de pruebas con 12 métodos de prueba para el método.

/**
* 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();
}

Resultados de ejecución de las pruebas del método seleccionado:

Pantallazo con el resultado de ejecución de las pruebas del método.

Apreciación final:

Apreciación final sobre la calidad de la clase que usted seleccionó.

 Podemos afirmar que:

o Ejecutar solo la aplicación de manera independiente usando su propio
método main (sin junit)
o Ejecutar la aplicación usando la clase donde hemos programado las
pruebas. En ese caso:
 El método main quedaria no operativo...
 Si en el se han definifo parametros tambien quedarian no
operativos (servirian los indicados en las pruebas test).
 La clase creada para pruebas test será la que lanza el código de
la clase elaborada para la aplicación.