Cunit en c

El sistema CUNIT se utiliza para realizar las pruebas unitarias en C, que permite la administración y ejecución de las pruebas. Cubre una amplia gama de afirmaciones para probar los tipos de datos de uso común y utiliza una arquitectura simple para crear estructuras de prueba. El código de prueba del usuario está vinculado con CUNIT, que está diseñado como una biblioteca estática. Podemos examinar el desempeño de las tareas y funciones del programa C utilizando el marco de prueba de CUNIT. Cada tarea particular del programa C tiene diferentes circunstancias de entrada y limitaciones de salida. Para usar la cunit para probar el programa C, debemos instalarla primero en nuestro sistema. Los pasos para instalar cunit se describen a continuación.

Cómo usar el marco de cunit en Ubuntu 22.04

Para utilizar el marco de pruebas de cunit en nuestro sistema, debemos seguir los pasos de instalación. Estos pasos se aplican al Ubuntu 22.04 sistema. Antes de la instalación, primero actualizamos nuestro sistema. El sistema requirió el privilegio de sudo para actualizarse con el comando APT.

Para adquirir privilegios de sudo, el terminal solicitó la autenticación del usuario de sudo. Luego, actualice los paquetes del sistema y sus dependencias, como se muestra a continuación.

Ahora, hemos instalado el marco de cunit utilizando el siguiente comando. Este comando puede instalar los paquetes LibCunitl, LibCunitl-Doc y LibCunitl-Dev desde el repositorio de paquetes.

Una vez que se ejecuta el comando de instalación de cunit, se requiere la contraseña del usuario. Los paquetes esenciales de la cunit se han instalado en nuestro Ubuntu 22.04.

Ejemplo 1

Completamos el paso de instalación del marco de cunit en la sección anterior. Ahora, hemos probado el método de suma y diferencia para ver los resultados esperados en el siguiente ejemplo utilizando el marco de prueba de cunits.

#incluir
#incluir
#incluir
#incluir
#Include "CUNIT/BASIC.H "
int init_suite (void) return 0;
int clean_suite (void) return 0;
int mysum (int a1, int b1)

int res1;
res1 = a1+b1;
devolver res1;

int mydiff (int a2, int b2)

int res2;
res2 = a2-b2;
devolver res2;

void test_mysum (void)

Cu_assert (4 == mysum (2,2));
Cu_assert (8 == mysum (5,3));
Cu_assert (2 == mysum (-2,4));
Cu_assert (7 == mysum (0,7));

void test_mydiff (void)

Cu_assert (3 == mydiff (5,2));
Cu_assert (-4 == mydiff (4,8));
Cu_assert (-7 == mydiff (-3,4));
Cu_assert (-9 == mydiff (0,9));

int main (nulo)

Cu_psuite psuite1, psuite2 = null;
if (cue_success != Cu_initialize_registry ())
return cu_get_error ();
psuite1 = cu_add_suite ("test suite1", init_suite, clean_suite);
if (null == psuite1)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite1, "\ n \ nsum testing testing \ n \ n", test_mysum)))

Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite1, "\ n \ ndiFference testing \ n \ n", test_mydiff)))

Cu_cleanup_registry ();
return cu_get_error ();

Cu_basic_run_tests ();
Cu_cleanup_registry ();
return cu_get_error ();

Primero, para generar la estructura de la cunidad, hemos insertado la biblioteca de cunit "cunit/básico.h "con la palabra clave incluida. Esta biblioteca C es para marcos de pruebas unitarias y ofrece una interfaz de salida de consola simple. Luego agregamos dos funciones, "init_suite" para la inicialización de la función de suite y "clean_suite" para la limpieza de la función de suite, a nuestro programa para probar.

A continuación, construimos métodos, "mysum" y "mydiff", para ser probados por la cunidad. Hemos llamado al constructor para estas funciones, que contiene las variables en las que se han realizado operaciones de suma y diferencia. A continuación, hemos establecido una función como "test_mysum" para probar. Dentro de la función, hemos empleado el método "cu_assert", donde se asignan las expresiones init para la suma. Igual que "test_mysum", hemos construido la función test_mydiff para probar la expresión para diferentes operaciones utilizando el método "cu_assert".

Luego, tenemos el código de corredor de cunit dentro del método principal. Aquí, hemos creado dos suites, "Psuite1" y "Psuite2", del método "Cu_Psuite" y asignaron a estas suites un valor nulo. Hemos creado estas suites para ejecutar la prueba de cunit que debe registrarse en el registro de pruebas. Antes de agregar las suites al "test_registry", creamos el registro y lo inicializamos con la "condición if". Hemos utilizado el método "cu_initialze_registry ()" para crear el registro para probar suites.

Después de eso, agregamos el PSUITE1 al registro de prueba invocando el método de cunit "cu_add_suite". Después de eso, agregamos nuestras pruebas, "test_mysum" y "test_mydiff", a las suites especificadas utilizando el método "cu_add_test ()". Al final, mostramos los resultados de la prueba de cunit llamando al método "cu_basic_run_tests ()" y limpiamos el registro una vez que los resultados se mostraron con éxito. El error encontrado al hacer las pruebas de cunit será lanzada por la función "cu_get_error ()".

El archivo de prueba de cunit anterior se guarda como mytest.archivo c. Hemos ejecutado este archivo C con el comando gcc. Hemos usado el indicador -lcunit para la ejecución del archivo de prueba de cunit. Con este comando, nuestro código se compila. Luego, ejecutamos el archivo mytest, y mostró los resultados esperados de la prueba de cunit ya que todas las pruebas se aprobaron sin ninguna falla.

Ejemplo 2

Tenemos otro ejemplo en el que hemos probado los dos métodos de manejo de archivos, "fread" y "fprintf", por el enfoque de cunit. Abrimos y cerramos el archivo temporal utilizando las funciones de prueba de cunit. Las operaciones de prueba de cunit prueban las funciones de la biblioteca escribiendo y leyendo desde el archivo temporal.

#incluir
#incluir
#incluir
#incluir
#Include "CUNIT/BASIC.H "
archivo estático* archivo = null;
int init_suite1 (void)

if (null == (file = fopen ("myfile.txt "," w+")))
regreso -1;

demás
regresar 0;


int clean_suite1 (void)

Si (0 != fclose (archivo))
regreso -1;

demás
archivo = null;
regresar 0;


void test_fprintf (void)

int x1 = 10;
Si (nulo != archivo)
Cu_assert (2 == fprintf (archivo, "q \ n"));
Cu_assert (7 == fprintf (archivo, "x1 = %d", x1));


void test_fread (void)

Buffer de char sin firmar [20];
Si (nulo != archivo)
Rewind (archivo);
Cu_assert (9 == fread (búfer, sizeof (unsigned char), 20, archivo));
Cu_assert (0 == strncmp (buffer, "q \ nx1 = 10", 9));


int main ()

Cu_psuite psuite = null;
if (cue_success != Cu_initialize_registry ())
return cu_get_error ();
psuite = cu_add_suite ("suite1", init_suite1, clean_suite1);
if (null == psuite)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite, "prueba de función fprintf ()", test_fprintf)) ||
(Null == cu_add_test (psuite, "test de función fread ()", test_fread))))

Cu_cleanup_registry ();
return cu_get_error ();

Cu_basic_set_mode (cu_brm_verbose);
Cu_basic_run_tests ();
Cu_cleanup_registry ();
return cu_get_error ();

Dentro del archivo de encabezado, hemos definido la biblioteca estándar de cunit "cunit.h/básico.H ". Luego, declaramos "archivo" como un puntero al archivo utilizado por las pruebas. A continuación, hemos construido la función "init_suite1" que abre el archivo temporal "myfile.txt ”y devuelve el valor cero en el éxito; de lo contrario, se devolverá un valor distinto de cero. Para cerrar el archivo, hemos creado la función de limpieza de suite, que también devuelve un valor distinto de cero en la falla al cerrar el archivo temporal. De lo contrario, al cerrar con éxito el archivo temporal, se obtiene un valor cero. Luego, simplemente hemos implementado una función "test_fprintf" donde hemos insertado los datos en el archivo temporal "myfile.TXT". Estas funciones de prueba también verificaron el número de bytes que intentamos escribir en el archivo.

Después de eso, creamos otra función para la función "test_fread" para probar el método Fread. Aquí, hemos verificado que los caracteres especificados están presentes en los datos escritos previamente por la función "test_fprinf ()". Luego, tenemos la función principal donde se manejan las pruebas configuradas y ejecutadas. Definimos el "Psuite" en la función principal e inicializamos el registro utilizando la función de prueba "Cu_initialize_Resgistry". También hemos llamado a la función "cu_add_suite" para agregar el conjunto al registro y agregado las pruebas especificadas a las suites con la ayuda de la función "cu_add_test".

Las interfaces de prueba de cunit básicas se utilizan al final para mostrar los resultados del código. Tenga en cuenta que la función principal devuelve un "cue_success" en la ejecución exitosa y un código "cunit_error" diferente a la ejecución fallida.

Hemos ejecutado el código anterior para la prueba de cunit, que mostró el resumen del programa y el mensaje de método de las pruebas exitosas.

Conclusión

CUNIT es un marco central que proporciona varias interfaces de usuario. Nos permite administrar suites de prueba, casos de prueba y registros de prueba. Las interfaces de usuario se facilitan la prueba de los programas y las interfaces de los usuarios se facilitan los resultados de esas pruebas. Hemos cubierto el marco de prueba de cunit en C con este artículo. Demostramos la instalación y luego implementamos dos programas de ejecución en el lenguaje C. Los programas anteriores probados han dado resultados exitosos.