PDF de programación - BUnit.h: Un módulo C++ simple para aprender prueba unitaria de programas

BUnit.h: Un módulo C++ simple para aprender prueba

unitaria de programas

Adolfo Di Mare

Universidad de Costa Rica
Escuela de Ciencias de la
Computación e Informática

+1 506 2207-4020

[email protected]



las otras herramientas más sofisticadas que usa el programador en
su práctica profesional. Aquí se argumenta que siempre es
necesario:
• Construir la especificación antes de la implementación.
•

los datos de prueba como parte de

Incorporar
especificación de cualquier módulo.

la

ABSTRACT
It is pleaded for the use of unit testing program tools. A scheme
for program implementation in which both the specification and
the unit test for each piece of software is developed before coding
algorithms. The experience on using
this approach with
programming students is reported.
RESUMEN
Se promociona el uso de herramientas para la prueba unitaria de
programas. Se propone un esquema de implementación de
programas en el que tanto la especificación y la prueba de cada
pieza de software se desarrolla antes de la codificación de los
algoritmos. Se reporta la experiencia del uso de este enfoque de
construcción de programas en estudiantes de programación.

Categorías y Descriptores
D.2.5
[Requirements/Specifications]: Tools.

[Testing and Debugging]: Testing

tools. D.2.1

Términos Generales
Algorithms, Documentation, Design, Economics.

Keywords
Prueba unitaria de programas, unit testing, ingenieria de sistemas,
software engineering.

1. INTRODUCCION

Mejorar la productividad del programador es esencial para
reducir el costo de construir sistemas de computación, pues la
mayor parte del presupuesto se invierte pagándoles. Por eso, el
entrenamiento de programadores enfatiza lograr que utilicen
herramientas sofisticadas que
les ayuden a aumentar su
productividad. Aunque ya se han logrando mejoras en la
productividad usando formas innovadoras de organización, como
las metodologías "ágiles" de "programación extrema" (XP:
eXtreme Programming) [2] o el uso de los lenguajes de cuarta
generación [6], todavía existe la expectativa de reducir más el
costo de la programación.

En este artículo se describe la herramienta BUnit, un módulo
[B]ásico para prueba [unit]aria de programas, que sirve para
lograr que un programador C++ adquiera la buena costumbre de
diseñar, especificar y probar antes de codificar los algoritmos de
un programa. La cualidad más importante del componente BUnit
es su sencillez, que lo hace ideal para mejorar la construcción de
programas; está diseñado para que los principiantes aprendan a
hacer prueba unitaria de programas y es un paso hacia el uso de

2. DOXYGEN ES PARTE DE LA
SOLUCIÓN
Así como las bailarinas son felices cuando danzan, los
programadores obtienen su gratificación cuando programan.
Escriben especificaciones obligados, pero prefieren invertir su
tiempo codificando (muchas veces están anuentes a escribir una
corta descripción de lo que hace cada módulo, aunque no quede
redactada de la mejor manera). Debido a que es necesario que el
programa funcione para que el cliente pague la siguiente cuota
pactada, el énfasis del entrenamiento del programador está en
lograr que implemente pronto el programa. Por eso pierden
importancia la documentación y, en especial, la especificación de
cada uno de los módulos de un sistema. Es particularmente difícil
que los programadores aprendan a especificar sus módulos, pues
pocos tienen la paciencia de redactar con cuidado sus ideas: son
"ingenieros", no "poetas". Herramientas como Doxygen [4] sirven
para mejorar significativamente la situación actual. En la
Universidad de Costa Rica se usa este generador de
documentación, desarrollado por Dimitri van Heesch [7], porque
es una herramienta que cubre un espectro más amplio que el de
herramientas
la
documentación para los lenguajes más populares: C++, Java, C#,
Visual Basic, SQL, etc.
El uso de herramientas para probar programas no representa
un enfoque revolucionario, pues no propone un nuevo paradigma
de programación, y más bien complementa los esquemas formales
usados para construir programas, en lugar de modificarlos o
anularlos. Por eso es una buena idea usar la prueba de programas
como una parte adicional de cualquier pieza de software. Aquí se
propone mejorar la construcción de sistemas incorporando la
prueba unitaria del módulo como parte de su especificación.
Una barrera que es necesario franquear es lograr permear a los
profesores y directores de proyecto para que acepten y adopten la
buen práctica de
las
especificaciones y los datos de prueba antes que los algoritmos.
Asimilar las técnicas de prueba unitaria de programas es más fácil
si se usa una herramienta que usan es adecuada y sencilla como la
pareja Doxygen-BUnit.

escribir programas

"JavaDoc", pues

sirve generar

construyendo

como

En la Universidad de Costa Rica el uso de BUnit y Doxygen
se ha logrado acostumbrando a los profesores a que sus alumnos
entreguen sus trabajos programados usando estas herramientas
que tienen la cualidad de que son fáciles de usar. En un ambiente
de trabajo de empresa en que la prueba unitaria de programas no
es una práctica cotidiana es posible lograr lo mismo.

3. ARQUITECTURA DE BUNIT
Chuck Allison implementó un pequeño módulo para probar
programas C++ [1] que disminuye el costo de aprender a usar
paquetes de calidad profesional como CppUnit. Sin embargo, usar
herramientas similares a CppUnit requiere del programador un
entendimiento profundo de cómo están construidas, y no sirve
para mejorar la especificación de los módulos. El módulo C++
BUnit que se presenta aquí es más simple que el propuesto por
Allison, y tiene la ventaja de que se puede usar con facilidad para
mejorar la documentación.

+----------------+
| TestCase |
+----------------+
| run() = 0 |
| successCount() |
| failureCount() |
| assertTrue() |
+----------------+
| Fixture |
| - setUp() |
| - tearDown() |
+----------------+

/\
||

+-------------------------+
| TestSuite< TestCase > |
+-------------------------+
| addTest ( TestCase & ) |
| addSuite( TestSuite & ) |
+-------------------------+

Figura 1. Clases de BUnit.

Como se muestra en la Figura 1, BUnit está constituida por 2
clases. La clase base TestCase que contiene la implementación de
la prueba y también la colección en donde están almacenados los
resultados de ejecutar
la prueba. La clase emplantillada
TestSuite<> contiene varias pruebas y, por comodidad, está
derivada de TestCase (se han usado los nombres en inglés para
mantener la compatibilidad con otras herramientas de la familia
"xUnit").
La cualidad que distingue a BUnit es que es muy simple, tanto
que su implementación completa reside en un único archivo de
encabezado: BUnit es una de las más simples herramientas de la
familia "xUnit", que es el nombre acuñado a partir de la
herramienta Java originaria: JUnit (varios de los miembros de esta
familia de herramientas para prueba unitaria de programas están
descritas en [8]). Si la herramienta es simple el programador
opondrá menos objeciones para usarla y también servirá para
integrar al aprendizaje de manera natural la programación el uso
de la prueba unitaria de programas. Como BUnit es simple
también es más fácil de documentar. Un diseño simple contiene
sólo las cualidades más importantes de la herramienta de manera
que sea el uso de otras herramientas más complicadas en donde se
incorporen las opciones y facilidades más sofisticadas.

Herramientas más complejas incorporan elementos gráficos
que ayudan al programador, como por ejemplo el uso de una
"barra de progreso" que indique cuánto falta para terminar, lo que
requiere mucha maquinaria programática que es necesario tomar
en cuenta y que por lo tanto incrementa la complejidad de la
herramienta. Otra importante cualidad de BUnit es que se usa de
una manera similar a JUnit, la herramienta de prueba unitaria que
la mayor parte de los programadores Java conocen, lo que facilita
el entrenamiento de nuevos programadores en herramientas más
sofisticadas, quienes eventualmente deben hacer esa transición.
BUnit se parece a JUnit para facilitar la transición entre ambas
herramientas. Para implementar una prueba unitaria con BUnit
basta seguir estos pasos:
1. Agregrar #include "BUnit.h" en el programa.
2. Derivar de TestCase una clase para implementar las pruebas.
Implementar en el método run() las pruebas invocando
3.
assertTrue().

4. Usar el método run() para ejecutar las pruebas.

#include "BUnit.h" // 1. Agregrar #include "BUnit.h"
/// Ejemplo mínimo de uso de \c BUnit.
class test0 : public TestCase {// #2. Derivar de TestCase
public:
bool run() {
assertTrue(1+1 == 3); // #3 Invocar assertTrue()



return wasSuccessful();
}



};
#include <iostream> // std::cout
/// Programa principal que ejecuta la prueba.
int main() {
test0 test0Instance;
if ( ! test0_instance.wasSuccessful() ) {
std::cout << test0_instance.report();
}
return 0;
}

Figura 2. El programa de prueba test0.cpp



test0Instance.run(); // #4 run(): Ejecuta la pruebas

El programa de la Figura 2 muestra cómo usar el método
assertTrue() para constatar que la expresión booleana que recibe
como argumento es verdadera. En este caso, debido a que la suma
1+1 es diferente de 3, el total de p