tabla - Prueba de unidad básica y C, ¿cómo empiezo?

unidades del sistema internacional de medidas (3)

Después de leer algunos hilos aquí en StackOverflow, he llegado a la conclusión de que debería adoptar algún tipo de prueba de desarrollo / unidad de prueba (o al menos explorar el área).

Y como estamos hablando del código c en Linux, decidí probarlo (no sé si esta es la opción correcta, pero si no sirve, siempre puedo intentar algo más adelante).

Pero dado que este concepto de pruebas unitarias y marcos de pruebas unitarias es totalmente nuevo para mí, comencé a hacer algunas pruebas de unidad en un código de prueba realmente pequeño (pero estaba totalmente perdido de todos modos y me parecía que me faltaba algo).

Esto es lo que he hecho hasta ahora, creé el siguiente archivo:

main.c, principal que solo llama a una función llamada my_pow e imprime el resultado.
my_pow.c, contiene la función my_pow.
my_pow.h
my_pow_test.c, pensé que debería colocar el código de unidad para la función my_pow aquí.

(Entonces, el "programa normal" es main.c, my_pow.c y my_pow.h).

Este es my_pow.c

#include "my_pow.h" int my_pow(int a, int b) { return (a*b); }

Entonces pensé que en my_pow_test.c puse algo como esto:

#include <check.h> #include "my_pow.h" START_TEST (test_my_pow) { /* unit test code */ } END_TEST //do I need some sort off main here that calls test_my_pow?

Esto es básicamente lo mismo que en el capítulo 3.1 del manual de verificación , pero aún no ...

¿Podría alguien por favor empujarme en la dirección correcta?

Gracias Johan

Actualización: No hay razón por la que intenté usar el control. Solo pensé que debería comenzar en algún lado, tal vez CUnit sea una mejor opción (creo que probaría eso también y luego tomaría una decisión educada).

Actualización: Gracias @philippe por señalar indirectamente que la documentación en línea es solo la mitad de la verdad, el código de ejemplo que aclara de qué se trata la documentación ya estaba instalado con el paquete de verificación. En el caso de Ubuntu / usr / share / doc / check / example / tests /

Actualización: El ejemplo del código se creó para que comenzaras mirando su primera versión, luego la segunda, etc. Para que pudieras seguir cómo crea un caso / código de prueba muy básico desde nada hasta algo que es útil en una forma TTD tradicional.

Y como mi código estaba roto y quería que la prueba de la unidad lo demostrara, hice trampa un poco y probé en contra de la verdadera función pow. Algo como esto:

START_TEST (test_my_pow1) { int resultat = my_pow(3,3); int math = pow(3,3); fail_unless ( resultat == math, "Error on 3^3 != %d (%d)",math, resultat); }

Sin embargo, en el futuro no reproduciré lo que ya está en los stdlibs :-)

Relacionado:

tomado de la búsqueda [c] [unit-testing] .

Estaría más inclinado a usar CUnit, que es parte de la serie X de frameworks de prueba.

Es escalable para grandes conjuntos de pruebas y ha estado en uso durante muchos años, por lo tanto maduro.

¿Alguna razón por la que no fuiste con CUnit?

HTH

aclamaciones,

Robar

He estado usando dejagnu por años y me encanta.

Empecé a usarlo para desarrollo integrado porque soporta muy bien el concepto de que la máquina en la que está ejecutando el programa de prueba puede ser diferente de la máquina en la que construye el programa de prueba. Una consecuencia de esto es que el código de prueba en múltiples plataformas también es bien soportado. No estoy seguro si eso es importante. El gcc testsuite lo usa. Lo uso para el desarrollo de escritorio también.

La idea básica con dejagnu es que tu

copie el programa de prueba al "objetivo" (que para las pruebas locales podría ser el directorio ~ / tmp)
iniciar el programa de prueba
imprime cosas en la consola (que actúa como entrada para el programa de prueba)
analizar el resultado del programa de prueba y relacionarlo con lo que espera
decidir si esa salida significa aprobar o no

Una vez que haya escrito el programa de prueba y los guiones de prueba, terminará haciendo algo como esto:

$ runtest === foo Summary === # of expected passes 42 foo-test built Thu Jan 15 20:09:19 PST 2009 foo-test version 0.0.0.1 runtest completed at Sun Jan 18 08:29:13 2009

La forma en que llego para probar una biblioteca llamada foo es:

supongamos que los archivos de fuente e inclusión para la biblioteca están en ~ / src / foo
crear un directorio llamado ~ / src / foo / testsuite
escriba un programa de prueba llamado foo-test.c que tenga un main () que

procesa args de línea de comando
- imprime un mensaje y se sienta en un bucle procesando "comandos" donde defino un comando para probar cada función en mi biblioteca. Esto es algo así como un shell de comandos, pero específico para la biblioteca. Para algo como my_pow, definiría el comando para tomar 2 argumentos.
escriba un dejagnu (que es otra capa encima de Expect (http://expect.nist.gov/, que es en sí misma una capa sobre la función Tcl (http://www.tcl.tk/) llamada my_pow que:

toma dos argumentos
calcula el resultado esperado (en Tcl)
envía "my_pow" a la consola
analiza el resultado del comando my_pow de foo-test
determina si el resultado real coincide con el resultado esperado
llama a la función de dejagnu apropiada (aprobado o no)

Suena difícil, pero no lo es. Toma un poco de tiempo decidir cuánto trabajo hacer en foo-test vs. cuánto hacer en Tcl. Terminé usando una gran cantidad de funcionalidad de shell (por ejemplo, bash) para hacer cosas como copiar archivos a directorios temporales o mirar los archivos de registro que generan mis programas. Así que terminas siendo bueno en todo esto.

En cuanto a las referencias, hay un libro en Expect que diría que es un requisito para sumergirse en esto: http://oreilly.com/catalog/9781565920903/index.html .
Entre eso y un comando de Tcl en línea, consulte http://www.tcl.tk/man/tcl8.4/TclCmd/contents.htm y preguntas frecuentes ( http://www.psg.com/~joem/tcl/faq.html ), estás bastante allí.

Buena suerte.

-DB

Usted creó un primer caso de prueba. Ahora necesita crear un banco de pruebas (un grupo de casos de prueba) y un corredor .

Le recomendaría que intente compilar su ejemplo primero para validar su entorno, aunque su documentación introduce un código nuevo a través de diff (parche de origen) que no considero muy conveniente.

Si alguna vez decides probar con otro framework ( me vino a la mente una minúscula ), puedo indicarte un " tutorial ".