Max Hernandez

Laberinto - Ejemplo de Canvas en HTML5

jueves, 14 de abril de 2011

Implementación de pruebas unitarias

Buen día.

Bueno para esta publicación me toca presentar las pruebas unitarias que implemente para mi proyecto las cuales son las siguientes :


Prueba Writer
Para realizar esta prueba utilice un archivo de texto llamado "ejemplo.txt" con este archivo en el método prueba cree dos objetos de este a partir del archivo, uno de los objetos lo sobrescribí con el contenido del archivo "ejemplo.txt" y el otro lo deje igual. Al comparar me dirían si el contenido del archivo se recuperaba exitosamente o si la clase tenia errores.

Este es el código de la prueba:
package pruebas;

import java.io.*;
import java.lang.StringBuffer;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

public class PruebaWriter extends TestCase {

    protected Writer w;
    private File prueba;
    private File secundario;
    private StringBuffer buffer = new StringBuffer();
    
    protected void setUp() {
 try{
     this.prueba = new File("ejemplo.txt");
     this.secundario = new File("ejemplo.txt");
     this.w = new Writer("",secundario,buffer);
 }catch(Exception e){
     e.printStackTrace();
 }
 return;
    }
    
    public static Test suite() {
 return new TestSuite(PruebaWriter.class);
    }

    public void testEscribiendo() {
 System.out.println("Escribiendo Documento...");
 buffer.append("Su hermano fue en su busca, a tierras muy lejanas.");
 w.escribirDocumento();
 w.cerrarArchivo();
 super.assertEquals(secundario,prueba);
 return;
    }

    public static void main(String[] args) {
 TestRunner.run(PruebaWriter.suite());
 return;
    }
}

Prueba Reader
Para comprobar el correcto funcionamiento de esta clase utilice un archivo de prueba llamado "ejemplo.txt" leyendo el contenido por medio de la clase Reader y después pasándolo a un String me fue mas fácil comparar ese String con otro que yo hice donde estaba el contenido que yo había puesto en archivo,


package pruebas;

import java.io.*;
import java.lang.StringBuffer;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

public class PruebaReader extends TestCase {

    protected Reader r;
    private File prueba;
    private StringBuffer buffer = new StringBuffer();
    
    protected void setUp() {
 try{
     this.prueba = new File("ejemplo.txt");
     this.r = new Reader("",prueba,buffer);
 }catch(Exception e){
     e.printStackTrace();
 }
 return;
    }
    
    public static Test suite() {
 return new TestSuite(PruebaReader.class);
    }

    public void testLeyendo() {
 System.out.println("Devolviendo Documento...");
 r.devolverDocumento();
 r.cerrarArchivo();
 super.assertEquals("Su hermano fue en su busca, a tierras muy lejanas.",buffer.toString());
 return;
    }

    public static void main(String[] args) {
 TestRunner.run(PruebaReader.suite());
 return;
    }
}

Prueba


Diseño de pruebas unitarias (clase)


(imagen obtenida de:https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjmNxRNBBszcJ_vwGtUBswRvnP6DIl7vxk7tL9nKxZi6KL93f7O1evFJ23s82qXj_9S7cH3kSjvMvcmKmEh4QkoKWU6b9LCGAvrzznSO0PO6JVgNN8QwmfdvleHX8IgAkXxz5RhEe5ZnRsL/s320/psicotecnico.jpg")



Buen día.
Esta semana voy dedicar esta publicación para hablar de las pruebas unitarias y de como voy a utilizar estas para verificar parte del contenido de mi código de proyecto.

Primero empezare definiendo pruebas unitarias.
Pues bien las pruebas unitarias son pruebas dirigidas a probar el correcto funcionamiento de las diferentes clases y métodos en nuestro sistema probandolos por separado.

Para hacer este tipo de pruebas en mi caso utilice JUnit que es un conjunto de clases que permite
realizar la ejecución de clases Java de manera controlada, para poder evaluar si el funcionamiento de cada uno de los métodos de la clase se comporta como se espera.

Utilizando JUnit
Para usar JUnit se crea una nueva clase java que es la que corre las pruebas y que siempre extiende a la clase TestCase del JUnit, Ahora para hacer las pruebas en esta clase crearemos métodos que empiezan con el nombre "test" así JUnit reconocerá los métodos que han de ser probados.

Métodos de comprobación:
assertEquals (valor_esperado, valor_real)
• Comprueba si “valor_esperado” y “valor_real” son iguales.
• “valor_real” es la salida que genera el método bajo prueba, “valor_esperado”
es lo que debería generar el método bajo prueba si funciona correctamente.
• Estos valores pueden ser de cualquier tipo nativo, de tipo String y Object (hay
distintos métodos para cada caso). Ojo, que si pasas arrays no los compara
elemento a elemento, sólo la referencia.

assertTrue (boolean condición)
• Comprueba que la condición es cierta.

assertFalse (boolean condición)
• Comprueba que la condición es falsa.

assertSame (Objeto esperado, Objeto obtenido)
• Comprueba que “obtenido” y “esperado” se refieren al mismo objeto.
Febrero 2004 JUNIT. Pruebas Unitarias 22
Pruebas con JUNIT: Explicación Formal (4)
Métodos de comprobación (2):

assertNotSame (Objeto esperado, Objeto obtenido)
• Comprueba que “obtenido” y “esperado” no se refieren al mismo objeto.

assertNull (Objeto objeto)
• Comprueba que el objeto indicado es nulo (referencia a null)

assertNotNull (Objeto objeto)
• Comprueba que el objeto pasado como parámetro no sea nulo (que referencia
a un objeto inicializado en memoria).

fail (String mensaje)
• Si en el código se alcanza y ejecuta esta sentencia, la prueba fallará.
• Se usa para marcar secciones de código que no deberían ejecutarse si todo
funcionara correctamente.
• Por ejemplo, justo después de una excepción para comprobar si ésta se lanza
correctamente.

Esta lista me sirvió de referencia para realizar las comprobaciones. Para utilizar estos, se llama al método o métodos a comprobar y por medio del valor regresado se comprueba si el método trabaja correctamente todo esto dentro del método test que corresponde  ala prueba.

TestReader
Para comprobar el correcto funcionamiento de la clase Reader cree un archivo de texto llamado "prueba.txt" y leí el contenido con esta clase con los métodos de la clase después compare el texto que ya sabía que tenía el archivo con el que me había regresado la clase.



TestWriter
Para comprobar la clase Writer simplemente cree dos objetos de el mismo archivo de prueba "prueba.txt" y sobre uno volví a rescribir el mismo texto que ya tenía al inicio lo compare con el objeto que no había sido editado y si los dos fuesen iguales la prueba era éxito los dos diferentes la prueba sería un fracaso.



Saludos.

referencias:
http://www.gsi.dit.upm.es/~legf/doc/lprg/Transparencias%20LPRG/Pruebas%20Unitarias.pdf
http://es.wikipedia.org/wiki/Prueba_unitaria
http://blog.continuum.cl/wp-content/uploads/2008/08/pruebas-unitarias.pdf

jueves, 7 de abril de 2011

Implementación de eventos, excepciones y errores propios (tall)

Buen día

En esta ocasión nos toco ver el tema de eventos, excepciones y errores así que para el taller de la materia identificamos los mismos en nuestro código para corregir o tratar errores y excepciones y mostrar o implementar eventos en o de nuestro código.

En primer lugar empezare con los ...

Eventos

Esta es la clase TextManager del proyecto que utilizo como escucha por cuestiones de comodidad ademas de ahorro de memoria. Esta clase tiene un método al cual se le notifica cuando ocurre un evento y sabe que hacer con este, todo esto hablando de la interfaz gráfica. hasta ahora solo tiene cuatro eventos pero cuando lleguemos al tema de interfaces gráficas probablemente tenga que agregar mas.

public class TextManager implements ActionListener { 
public void actionPerformed(ActionEvent e){
String cmd = e.getActionCommand();

if(cmd == "abrir")
this.abrir();

if(cmd ==  "nuevo")
System.out.println("Se ha picado nuevo");

if(cmd == "guardar")
this.guardar();

if(cmd == "guardarComo" )
this.guardarComo();
}
};

public class GUI extends javax.swing.JFrame{
public void barraPrincipal(TextManager listener){

JMenuItem abrir = new JMenuItem(jMenu[2]);
JMenuItem nuevo = new JMenuItem(jMenu[3]);
JMenuItem guardar = new JMenuItem(jMenu[4]);
JMenuItem guardarComo = new JMenuItem(jMenu[5]);
abrir.addActionListener(listener);
abrir.setActionCommand("abrir");
nuevo.addActionListener(listener);
nuevo.setActionCommand("nuevo");
guardar.addActionListener(listener);
guardar.setActionCommand("guardar");
guardarComo.addActionListener(listener);
guardarComo.setActionCommand("guardarComo");
}
};

Utilizo un solo escucha por que en mi caso el escucha utiliza el patrón Singleton puesto que si se crearan varios dividiría el programa en partes y seria menos eficiente.

Errores

Solo he tomado en cuenta dos errores y son la falla de alguna de estas clases del programa puesto que son las mas importantes y solo pueden ser implementadas una ves. así que en caso de que fallen falla todo el programa y no queda mas opción que terminarlo.

La clase TextManager que se encarga de administrar los archivos que se abren para editarlo, los que se crean y los que se guardan, ademas que sirve de escucha para los eventos generados por la interfaz gráfica.
try {
textActions = TextManager.obtenerInstancia(hojas);
}catch(Error e){
e.printStackTrace();
System.out.println("TextActions No se ha iniciado correctamente");
}

La clase GUI que contiene las hojas que sirven de campo de trabajo y cualquier opción controlable por el usuario, sin esta no tendría mucho sentido que siguiera ejecutándose el programa.
try {
GUI ventana = GUI.obtenerInstancia("MxText",hojas);
ventana.barraPrincipal(textActions);
}catch(Error e){
e.printStackTrace();
System.out.println("GUI No se ha iniciado correctamente");
}


Excepciones

Esta excepción se debería tirar al no poder abrir un archivo esta excepción notifica al TextManager que no fue posible abrir el documento para informarle al usuario.
public class Reader{
// Atributos
public String nameFile;
private File ar=null;
private FileReader fr=null;
private BufferedReader into =null;
private StringBuffer buffer =null;

//Constructor
public boolean abrirDocumento(){
try{
ar =fl;
fr = new FileReader(ar);
into = new BufferedReader(fr);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
};


Esta excepción al igual que la anterior notifica ala clase TextManager por medio de un valor booleano que no se puedo guardar el archivo.
public class Writer{

// atributos
private String nameFile;
private File ar=null;
private FileWriter fw=null;
private StringBuffer buffer =null;
/**
* Constructor que ocupa la direccion del archivo con la informacion dada.
*/
public boolean guardarDocumento (){
try{
if(fl == null){
ar=new File(name);
}else{
ar =fl; }
fw = new FileWriter(ar);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
];

En caso de que haya una excepción al devolver el documento entonces borra lo que haya agregado al buffer y devuelve un falso para que la clase TextManager sepa que hacer.
public class Reader{
public boolean devolverDocumento(){
 int c;
 try{
 while( (c = into.read()) != -1){
 buffer.append((char)c); 
 }
 return true;
 }catch(Exception e){
 e.printStackTrace();
 buffer.delete(0,buffer.capacity());
 return false;
 }
 
}

};

En caso de que al guardar haya un error en la clase Writer devuelve lanza la excepción y devuelve un valor falso.
public class Writer{
public boolean escribirDocumento(){
 try{
 fw.write(buffer.toString());
// es como solia decir la abuela argaslakslasdlaskjlaklskaslsj X_X
// abuela? abuela!!? :(
 return true;
 }catch(Exception e){
 e.printStackTrace();
 return false;
 }
}

};


Esas son algunos de mis eventos, excepciones y errores de mi proyecto saludos.

lunes, 4 de abril de 2011

Identificación de eventos, excepciones y errores propios (clase)

Buen día.
En esta semana me toca hablar acerca de los eventos, errores y las excepciones primero empezare definiendo cada concepto.

Errores
Es el resultado de un fallo o deficiencia durante el proceso de creación de programas de ordenador o computadora (software). Dicho fallo puede presentarse en cualquiera de las etapas del ciclo de vida del software aunque los más evidentes se dan en la etapa de desarrollo y programación. Los errores pueden suceder en cualquier etapa de la creación de software.

ejemplo:

[Imagen obtenida de "http://www.rpggamerpro.com/NWN_NO%20Disk_Windows_Error.jpg"]
Cuando se genera un error en el programa este no tiene otra opción que terminar su ejecución.

Eventos
Un evento es una acción del usuario ante la cual puede realizarse algún proceso.


Este es un ejemplo de un evento donde el botón abrir tiene asignado un escuchador, así que cuando el usuario presiona abrir el escuchador hace que se imprima el mensaje "se ha picado nuevo" en la pantalla.


Excepciones
Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias.

ejemplo


Esta excepción la produjo mi programa cuando intente abrir un archivo que estaba en una usb pero saque esta justo cuando lo estaba escogiendo, el programa me mostró un mensaje de error y el programa me creo una nueva hoja pero sin ningún archivo asignado así que me mostrara una hoja vacía lo cual puede traer problemas al usuario para evitar esto debo tratar esta excepción y pedir .


Para esta publicación voy a identificar algunos de los errores y excepciones que puedan ocurrir en mi software para así mas adelante saber como tratar con ellos. además de mostrar los eventos que tengo hasta ahora en mi software.

Eventos
  • Tengo un evento por cada botón que tengo en mi interfaz gráfica.
  • Estoy pensando en la idea de añadir un evento para cuando escriba algo



Errores
  • No poder iniciar la interfaz gráfica, problemas en la clase GUI.
  • No poder iniciar la clase TextManager que es la que controla los archivos que se abren.



Excepciones
  • Tratar de abrir un archivo que que ha sido movido mientras se selecciona y mostrar en la pantalla que se ha abierto.
  • Tratar de guardar un archivo que eh sido modificado u eliminado por otro programa mientras se trabajaba con el.
  • Recuperar solo parte del archivo por la clase Reader o escribir solo parte por la clase Writer.
  • Al abrir, leer, escribir y cerrar en un archivo cualquier excepción.