Java: pruebas unitarias con JUnit y NetBeans

Si desarrolláis en Java seguramente hayáis utilizado algún entorno de desarrollo (o IDE) como Eclipse o NetBeans. El siguiente tutorial está centrado en el uso de JUnit en NetBeans (usamos la versión 7.0).

Las pruebas unitarias son las que realizamos sobre cada uno de los componentes que forman parte de la aplicación. Vamos a partir de una clase Java que implementa cuatro operaciones básicas de una calculadora: suma, resta, multiplicación y división. Podéis acceder al proyecto completo de este tutorial en este enlace.

Descomprimimos el proyecto y lo abrimos desde NetBeans. Para implementar las pruebas con JUnit abrimos la clase Calculando.java y seleccionamos el menú Herramientas > Crea pruebas con JUnit:

En el cuadro de diálogo siguiente elegimos JUnit 4.x

En el diálogo siguiente mantenemos las opciones por defecto y aceptamos:

Ahora podemos acceder a la clase "CalculandoTest" creada en el paquete "Paquetes de prueba":

Éste método que vemos en la imagen superior es un prototipo (tiene los valores establecidos a cero y una función "fail()" que lanza un fallo en el método. Si ejecutáramos la prueba (ejecutando la clase, con Alt + F6 o con el menú contextual sobre el menú del proyecto > Probar) se produciría el siguiente resultado:

Falla porque debemos implementar los valores de los parámetros y el resultado previsto (cada uno de los casos de prueba) para cada método probado. Podemos implementar los casos de prueba estableciendo los valores de entrada, el valor esperado de cada operación y comentando (o eliminando) la llamada a la función fail(). Os mostramos un ejemplo con el método testMultiply():

Una vez establecidos todos los casos de prueba (valores para todos los métodos) ejecutamos de nuevo las pruebas (menú contextual > Probar sobre el proyecto, ejecutar la clase test o con Alt + F6):

Como vemos si las pruebas son satisfactorias aparecerá como la imagen superior. Podéis encontrar el código de la clase de ejemplo y de test en el proyecto en el enlace del primer párrafo:

https://mega.co.nz/#!MwhBGKBL!HEIxk12AZIYs8XgZUNWXqjEL1qNts6SRK3FZXz59Qd8

Fichero log: redirigir la salida de Java a un fichero

Hoy vamos a incluir cómo hacer un método que redirija la salida de Java a archivo para hacer un archivo log. El proceso es tan sencillo como utilizar dos métodos de la clase System: setErr y setOut, pasando como parámetro un objeto de tipo PrintStream.

El método propuesto es el siguiente:

public static void standardIO2File(String fileName){

        if(fileName.equals("")){//Si viene vacío usamos este por defecto

            fileName="C:\\javalog.txt";

        }

        try {

            //Creamos un printstream sobre el archivo permitiendo añadir al

            //final para no sobreescribir.

            PrintStream ps = new PrintStream(new BufferedOutputStream(

                    new FileOutputStream(new File(fileName),true)),true);

            //Redirigimos entrada y salida estandar

            System.setOut(ps);

            System.setErr(ps);

        } catch (FileNotFoundException ex) {

            System.err.println("Se ha producido una excepción FileNotFoundException");

        }

    }

Como veis el método es muy sencillo: pasamos como parámetro un String con el nombre (y ruta) del fichero y creamos sobre él un PrintStream que pasaremos como argumento a los métodos setOut y setErr. Estos métodos redirigen al fichero la salida estándar y la de error. Podemos codificar el método con dos argumentos para redirigir la salida estándar a un fichero y la de error a otro, eso queda a gusto del consumidor.

Argumentos en línea de comandos con NetBeans

Si programáis en Java es bastante probable que utilicéis un IDE integrado como Eclipse o NetBeans. Yo utilizo este último y hace poco tuve que trastear con él para encontrar algo trivial: cómo pasarle parámetros en línea de comandos a un proyecto.

En realidad se trata de un proceso muy sencillo. En primer lugar creamos una clase sencillita de Java para ilustrar el ejemplo. Se trata de una clase que imprime el primer argumento recibido en línea de comando por pantalla:

Si ejecutamos el proyecto nos aparecerá en blanco y el mensaje "Generación Correcta (...)". Si generamos el .jar podemos ejecutarlo desde la consola del sistema operativo y pasar argumentos con el comando "java -jar nombreArchivo.jar [argumentos]".

Si queremos ejecutarlo desde NetBeans con argumentos sólo tenemos que abrir el menú contextual (botón derecho del ratón) sobre el proyecto > Establecer la Configuración > Personalizar:

Se abre un diálogo modal con el campo "Argumentos", el cual podemos rellenar como si se tratara de la línea de comandos.

Pulsamos aceptar y cuando ejecutamos el proyecto ya podemos ver la salida del mismo:

Java: borrar todas las filas de un JTable

La forma más usual de presentar una lista de resultados es utilizando una tabla en la que cada fila corresponde a cada elemento del resultado. En Java es frecuente utilizar jTable con un modelo DefaultTableModel (llamado miModelo en el ejemplo). Para que el método funcione es necesario declarar el modelo como variable de la clase.

Si queremos realizar filtros tenemos que eliminar los resultados previos de la tabla (en cristiano: vaciarla). Este sencillo método permite hacerlo con facilidad eliminando las filas del modelo de la tabla:

void LimpiarJTable(){
        int a =miModelo.getRowCount()-1;  //Índices van de 0 a n-1
        //System.out.println("Tabla "+a);   //Para mostrar por consola el resultado
        for(int i=a;i>=0;i--){ 

            //System.out.println("i "+i);    //Para mostrar por consola el resultado
            miModelo.removeRow(i);
        }
    }

Podéis descomentar las salidas por consola para comprobar el funcionamiento del método.

Java en Android

Si tienes un terminal Android (teléfono, tablet...) seguramente habrás echado de menos que no ejecute java en alguna ocasión. Desde juegos hasta aplicaciones de turismo (si te gusta viajar habrás encontrado esos puntos que dicen: ¡Enciende el Bluetooth y descarga la guía de visita...!), pasando por el desarrollo de nuevas aplicaciones (como es nuestro caso), es interesante poder ejecutar archivos de java en nuestro terminal. La mala noticia es que Android no soporta una máquina virtual Java de forma nativa en estos momentos. La buena es que existen emuladores para todo: consolas de videojuegos, sistemas operativos como el propio Android y, como no, de la máquina virtual de Java.

El problema

Después de quemar unas cuantas neuronas aprendiendo a desarrollar aplicaciones java para dispositivos móviles nos encontramos con un problema a la hora de probarlas en real. Disponemos de un terminal iPad (iOS): no soporta java. Disponemos de otro terminal Android: no soporta java... vamos, que tenemos que recurrir a un móvil casi obsoleto para probar los .jar.

Pero, ¿por qué? Con lo fácil, flexible y potente que es trabajar con Java. La alternativa es programar en otro tipo de lenguajes (ActiveC, Adobe Flash...), pero eso será objeto de otros post. Aquí nos interesa ejecutar java en Android.

phoneME

Como casi siempre en informática, no somos los únicos que tenemos este mismo problema y hay gente mucho más especializada que aporta soluciones (bendita comunidad internauta).

La solución que nos ha solucionado un poquito la existencia ha sido phoneME (podéis visitar su web aquí). Se trata de una implementación de J2ME (Java2 Micro Edition para los profanos) para diferentes sistemas operativos entre los que se encuentra Android (si queréis más información sobre la versión de phoneME para Android podéis encontrarla aquí).

Instalación

En la sección de descargas de la página de phoneME podemos encontrar las versiones para los distintos sistemas operativos. A nosotros nos interesa el siguiente perfil:

phoneME Advanced - Foundation Profile + MIDP High Resolution b168 rev20547 (apk)

Se trata del perfil MIDP para ejecutar MIDlets en alta resolución (más de 240x320 pixels). Descargaremos un archivo APK que instalaremos en nuestro dispositivo Android.

Funcionamiento

Para ejecutar un archivo .jar tenemos dos opciones: 

1. Si sólo tenemos el .jar debemos ejecutarlo desde phoneME (interfaz un poco engorrosa)
2. Si disponemos del .jad y el .jar podemos utilizar un explorador de ficheros como el Astro y asignar la extensión .jad al phoneME (mucho más agradable de utilizar).

Vamos a centrarnos en la primera forma, por si acaso no tenéis el Astro todavía (mal, os recomiendo que lo probéis ;). El primer paso (y obvio) es pasar el .jar al terminal (por bluetooh, wifi, cable USB o como prefiráis). Una vez allí tomad nota de la ruta absoluta donde se ubica (en nuestro caso la carpeta de entradas de bluetooth: /mnt/sdcard/bluetooth) y el nombre del archivo. Esto es necesario porque phoneME no dispone de un módulo de exploración de ficheros: tendremos que darle la URL de nuestro archivo y pulsamos ejecutar:

Como podéis ver es un MIDlet sencillo desarrollado por nosotros, pero el programa es capaz de ejecutar MIDlets más complejos o incluso aplicaciones con la configuración CDC (instalando el apk correspondiente).

Espero que os resulte útil, si tenéis alguna pregunta no dudéis en escribir el comentario!