PDF de programación - Aprendizaje Java acelerado por casos de prueba JUnit

Imágen de pdf Aprendizaje Java acelerado por casos de prueba JUnit

Aprendizaje Java acelerado por casos de prueba JUnitgráfica de visualizaciones

Actualizado el 18 de Mayo del 2018 (Publicado el 3 de Mayo del 2017)
554 visualizaciones desde el 3 de Mayo del 2017
151,9 KB
7 paginas
Creado hace 9a (22/07/2010)
Aprendizaje Java acelerado por casos de prueba

JUnit

Adolfo Di Mare

Escuela de Ciencias de la Computación e Informática

Universidad de Costa Rica

adolfo.dimare@ecci.ucr.ac.cr

Resumen La herramienta JUnit para prueba unitaria de módulos se
puede usar para lograr que el aprendiz de programación Java no necesite
conocer con gran detalle la sintaxis del lenguaje, permitiéndole que desde
el principio se concentre en construir algoritmos, lo que facilita y acelera
la primera etapa del aprendizaje de la programación.
Palabras clave Prueba unitaria de programas, programación por ejem-
plos, introducción de técnicas de programación, software.

1.

Introducción

Java ha ganado popularidad como el primer lenguaje de programación por
muchas razones [1]: es un lenguaje completo que además es muy utilizado en la
industria [2]. Sin embargo, para programar en Java es necesario conocer antes su
sintaxis con buen detalle y además es necesario utilizar un entorno de desarrollo
adecuado para la implementación de programas (IDE: “Integrated Development
Environment”). Muchos docentes han tratado de evadir la complejidad sintáctica
de Java introducciendo objetos antes de hablar de algoritmos [3]. El entorno de
desarrollo BlueJ para Java es un es ejemplo de cómo la automatización se usa
para producir el esqueleto de las clases a partir de objetos que se visualizan en
un ambiente gráfico [4].

Discutir si se debe enseñar algoritmos primero vs. objetos primero no es el
objetivo de este trabajo, pues se parte de la suposición de que el docente cuenta
con herramientas que le permitan mostrarle a sus estudiantes hacia adónde va el
aprendizaje, de manera que ellos puedan construir su propio modelo intelectual
para lograr aprender, como lo expone BenAri [5] cuando justifica la herramienta
Jeliot para visualizar la ejecución de algoritmos Java [6]. Más bien aquí se mues-
tra que JUnit sirve para que el docente pueda saltar sobre una buena parte de
la sintaxis Java para sumergir a sus estudiantes directamente en la construcción
de algoritmos sencillos muy rápidamente. El entorno de desarrollo DrJava es el
prefirido del autor, pues es liviano y se puede ejecutar desde la llave maya, lo
que les permite a los estudiantes usar cualquier equipo para hacer sus prácticas
[7].

Si el profesor puede mostrar rápido los componentes más importantes de
la programación Java tendrá más tiempo para examinar conceptos avanzados,

2

Aprendizaje Java acelerado por casos de prueba JUnit

como parametrización o concurrencia; de lo contrario debe invertir una buena
parte de su curso lidiando con la sintaxis de Java.

Aquí proponemos el uso de datos de prueba JUnit para alcanzar el siguiente
objetivo del primer curso de programación: “Proveer al estudiante la forma-
ción básica en programación y construcción de algoritmos para su adecuado de-
sempeño en los cursos subsiguientes de la carrera, fomentándole sus habilidades
generales para la resolución de problemas”.

2. JUnit en 3 párrafos

Los adeptos a la llamada “Programación Extrema” han construido muchas
herramientas que les permiten probar primero, luego codificar y por último depu-
rar [8]. No hay que discutir si este paradigma es apropiado o no para utilizar sus
herramientas para la enseñanza. JUnit es un conjunto de clases Java orientado
a ejercitar todos los componentes de un programa para determinar si funcionan
correctamente [9]. JUnit permite hacer la prueba unitaria de módulos ya sean
rutinas simples, métodos complejos o programas completos.

En el corazón de JUnit está el verbo “assertTrue(cond)” que evalúa su ar-
gumento y acumula las ocasiones en que resulta falso; cada condición “(cond)”
representa un dato de prueba o un caso de prueba. Por ejemplo, si el sumador
“Bib.sume(3,5)” no es 8, esta invocación graba el hecho que puede ser reportado
luego por JUnit:

assertTrue( 8 == Bib.sume(3,5) ); // JUnit registra si falla

La arquitectura de JUnit es particular para el lenguaje Java, pero indepen-
dientemente de cómo está hecha funciona bien y es muy utilizada tanto en la
academia como en al industria. La prueba unitaria se puede utilizar para com-
plementar la especificación de módulos, como se muestra en [10] en el contexto
de C++.

3. Un ejemplo JUnit sencillo

Para que el estudiante aplique ciclos y sencuenciación el profesor muchas
veces le pide que sume los valores almacenados en un vector. Así surge el método
entero “sumador(int[])” que retorna la suma de los valores del vector.

Aprendizaje Java acelerado por casos de prueba JUnit

3

public static int sumador( int VEC[] ) {

if ( VEC.equals(null) ) { // VEC[] no existe todavia

return 0;

}
else if ( VEC.length==0 ) {

return 0;

}
int suma = 0; // acumulador
{

/******************************\
*
*
*
*
*
*
\******************************/

RELLENE CON SU ALGORITMO

}
return suma;

}

int suma = 0; // acumulador
{

RELLENE CON SU ALGORITMO

// Solucion
/******************************\
*
*
*
*
*
*
\******************************/
final int N = VEC.length;
for ( int i=0; i<N; ++i ) {

suma = suma + VEC[i];

}

}

Figura 1: Rellene con su algoritmo

En la Figura 1 se muestra la implementación del método “sumador()”: falta
un bloque de código que el alumno debe rellenar con la siguiente implementación
que se muestra en la parte inferior (o con una equivalente). Este ejercicio le
permite al profesor concentrar la atención del estudiante en el algoritmo de
suma, sin examinar el resto del código. Por ejemplo, pueden pasar varias sesiones
de trabajo antes de que el profesor explique por qué sumador() es un método
“estático” o que muestre que la comparación con el valor “null” usando el método
“equal()” mejora la implementación porque generaliza los valores a los que se
puede aplicar sumador().

4

Aprendizaje Java acelerado por casos de prueba JUnit

/** test -> {@code sumador()}. */
public void test_sumador() {

{ int V[] = { 1,2,3,4,5 }; assertTrue( sumador(V) == 15 ); }
{ int V[] = { 2,2,2,2,2 }; assertTrue( sumador(V) == 10 ); }
{ int V[] = { 8,0,2,1,9 }; assertTrue( sumador(V) == 20 ); }
{ int V[] = { 4,3,2,1,0 }; assertTrue( sumador(V) == 10 ); }
{ int V[] = { 0,1,2,3,4 }; assertTrue( sumador(V) == 10 ); }

}

Figura 2: Pruebas para sumador()

En la Figura 2 está la implementación del método JUnit que hace la prueba.
Esta prueba fue preparada de antemano por el profesor y es el trabajo del alumno
lograr que su programa funcione. Es sencillo saber si ya el alumno terminó su
práctica, pues la ejecución que se produce al pulsar el botón [Test] en DrJava
resulta en una barra verde, de lo contrario el IDE retorna un error marcando el
renglón con el color amarillo [7].

import junit.framework.*;

/** Datos de prueba para {@code sumador(int[])}. */
public class TestSumador extends TestCase {

/** Suma de los valores de {@code VEC(int[])}. */
public static int sumador( int VEC[] ) {

{

// ...
/******************************\
*
*
*
*
*
*
\******************************/
}

RELLENE CON SU ALGORITMO

}
/** test -> {@code sumador()}. */
public void test_sumador() {

// ...

}

}

Figura 3: Estructura del programa JUnit completo

En la Figura 3 se muestra la estructura del programa JUnit completo. El
método “sumador()” es el que debe completar el alumno, y “test sumador()” es
el método que contiene los datos de prueba; es importante que el nombre del
método de prueba comience con “test” porque así JUnit lo puede encontrar y eje-
cutar dinámicamente, en tiempo de ejecución. La parte marcada “** RELLENE
CON SU ALGORITMO **” es la que debe completar el estudiante.

Muchas veces conviene que el profesor resuelva varios problemas similares
a los que debe enfrentar el alumno. Pese a que el profesor debe trabajar un

Aprendizaje Java acelerado por casos de prueba JUnit

5

poquito más al impartir lecciones y prácticas, pues debe implementar tanto los
ejercicios como sus soluciones antes de presentarlas a sus estudiantes, a fin de
cuentas es posible lograr que los estudiantes trabajen pronto en programas que
no se limitan a una docena de líneas de código, como por ejemplo el juego de
“Toques y Famas” de esta tarea programada:

http://www.di-mare.com/adolfo/cursos/2009-2/pi-ta-3.htm
% http://www.di-mare.com/adolfo/cursos/2009-2/pi-ta-4.htm

Si el algoritmo escrito por el estudiante es incorrecto, la ejecución JUnit del
programa de prueba produce un error que aparece en amarillo en DrJava. Lo
mismo ocurre si el programa tiene un error de sintaxis.

for ( int gM=1; gM<=5; ++gM ) {

{
suma = suma + VEC[i-1];}}

Figura 4: Mala indentación

La dificultad de aprender Java disminuye porque el IDE DrJava le presenta
al estudiante los errores de lógica y de sintaxis de la misma manera: el renglón en
donde está el error queda pintado de color amarillo. Sin embargo, los estudiantes
pueden cometer errores muy creativos, como los que se muestran en Figura 4, en
donde el espaciado, la indentación y la elección de lo identificadores es incorrecta.
Además, también puede ocurrir que el profesor olvide cubrir todos los casos
pertinentes, como ocurre en este ejemplo en que el alumno ha evitado usar la
propiedad VEC.length sustituyéndolo por un valor fijo que no produce errores,
pues todos los datos de prueba usan un vector que almacena 5 valores. Por eso es
importante revisar el algoritmo escrito por cada estudiante, para determinar si
es una solución muy particular y para verificar que el formato de la codificación
es correcto [11].
Si por error un alumno borra algún corchete “{ }” o modifica el código que
está fuera del ámbito marcado “** RELLENE CON SU ALGORITMO **” de-
berá comenzar desde el principio, cargando una copia limpia del código, pues de
lo contrario le será prácticamente lograr que el programa compile correctamente.
También ocurre muchas veces que los novatos usan lógica estrambótica para su
solución (pues todavía no saben programar).

4. Conexión JUnit <=
  • Links de descarga
http://lwp-l.com/pdf3295

Comentarios de: Aprendizaje Java acelerado por casos de prueba JUnit (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad