El sistema CUnit s'utilitza per realitzar les proves unitàries en C, que permet l'administració i l'execució de les proves. Cobreix una àmplia gamma d'afirmacions per provar els tipus de dades d'ús habitual i utilitza una arquitectura senzilla per crear estructures de prova. El codi de prova de l'usuari està enllaçat amb CUnit, que està dissenyat com una biblioteca estàtica. Podem examinar el rendiment de les tasques i funcions del programa C mitjançant el marc de prova CUnit. Cada tasca particular del programa C té circumstàncies d'entrada i limitacions de sortida diferents. Per utilitzar el CUnit per provar el programa C, primer hauríem d'instal·lar-lo al nostre sistema. Els passos per instal·lar CUnit es descriuen a continuació.
Com utilitzar el marc CUnit a Ubuntu 22.04
Per utilitzar el marc de proves CUnit al nostre sistema, hem de seguir els passos d'instal·lació. Aquests passos s'apliquen al sistema Ubuntu 22.04. Abans de la instal·lació, primer vam actualitzar el nostre sistema. El sistema necessitava privilegis sudo per actualitzar-se amb l'ordre apt.
Per adquirir privilegis sudo, el terminal va demanar l'autenticació a l'usuari sudo. A continuació, actualitzeu els paquets del sistema i les seves dependències, tal com es mostra a continuació.
Ara, hem instal·lat el marc CUnit mitjançant l'ordre següent. Aquesta ordre pot instal·lar els paquets libcunitl, libcunitl-doc i libcunitl-dev des del dipòsit de paquets.
Un cop executada l'ordre d'instal·lació de CUnit, cal la contrasenya d'usuari. Els paquets essencials de CUnit s'han instal·lat al nostre Ubuntu 22.04.
Exemple 1
Hem completat el pas d'instal·lació del marc CUnit a la secció anterior. Ara, hem provat el mètode de suma i diferència per veure els resultats esperats a l'exemple següent utilitzant el marc de proves CUnit.
#include
#inclou
#inclou
#inclou
#include 'CUnit/Basic.h'
int init_suite ( buit ) { tornar 0 ; }
int suite_neta ( buit ) { tornar 0 ; }
int MySum ( ets a1, ets b1 )
{
int res1;
res1 =a1+b1;
tornar res1;
}
int MyDiff ( int a2, int b2 )
{
int res2;
res2 =a2-b2;
tornar res2;
}
void test_MySum ( buit )
{
WITH_ASSERT ( 4 ==La meva suma ( 2 , 2 ) ) ;
WITH_ASSERT ( 8 ==La meva suma ( 5 , 3 ) ) ;
WITH_ASSERT ( 2 ==La meva suma ( - 2 , 4 ) ) ;
WITH_ASSERT ( 7 ==La meva suma ( 0 , 7 ) ) ;
}
void test_MyDiff ( buit )
{
WITH_ASSERT ( 3 ==MyDiff ( 5 , 2 ) ) ;
WITH_ASSERT ( - 4 ==MyDiff ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==MyDiff ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==MyDiff ( 0 , 9 ) ) ;
}
int principal ( buit )
{
CU_pSuite pSuite1,pSuite2 = NULL;
si ( CUE_ÈXIT ! = CU_inicialitza_registre ( ) )
tornar CU_get_error ( ) ;
pSuite1 = CU_add_suite ( 'Suite de proves 1' , init_suite, clean_suite ) ;
si ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
si ( ( NULL == CU_add_test ( pSuite1, ' \n \n Prova de funció de suma \n \n ' , prova_MySum ) ) )
{
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
si ( ( NULL == CU_add_test ( pSuite1, ' \n \n Prova de funció de diferència \n \n ' , prova_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
Primer, per generar l'estructura CUnit, hem inserit la biblioteca CUnit “CUnit/Basic.h” amb la paraula clau inclosa. Aquesta biblioteca C és per a marcs de prova d'unitats i ofereix una interfície de sortida de consola senzilla. A continuació, hem afegit dues funcions, 'init_suite' per a la inicialització de la funció suite i 'clean_suite' per a la neteja de la funció suite, al nostre programa per a la prova.
A continuació, vam construir mètodes, 'MySum' i 'MyDiff', per ser provats pel CUnit. Hem anomenat el constructor d'aquestes funcions, que conté les variables sobre les quals s'han realitzat les operacions de suma i diferència. A continuació, hem establert una funció com a 'test_MySum' per provar. Dins de la funció, hem emprat el mètode 'CU_ASSERT', on s'assignen les expressions d'inici per a la suma. Igual que 'test_MySum', hem construït la funció test_MyDiff per provar l'expressió per a diferents operacions mitjançant el mètode 'CU_ASSERT'.
Aleshores, tenim el codi del corredor CUnit dins del mètode principal. Aquí, hem creat dues suites, 'pSuite1' i 'pSuite2', a partir del mètode 'CU_pSuite' i hem assignat a aquestes suites un valor NULL. Hem creat aquestes suites per executar la prova CUnit que s'hauria de registrar al registre de proves. Abans d'afegir les suites a 'test_registry', vam crear el registre i l'hem inicialitzat amb la 'condició si'. Hem utilitzat el mètode 'CU_initialze_registry()' per crear el registre per provar suites.
Després d'això, vam afegir pSuite1 al registre de prova invocant el mètode 'CU_add_suite' de CUnit. Després d'això, vam afegir les nostres proves, 'test_MySum' i 'test_MyDiff', a les suites especificades mitjançant el mètode 'CU_add_test()'. Al final, vam mostrar els resultats de la prova CUnit trucant al mètode 'CU_basic_run_tests()' i vam netejar el registre un cop els resultats es van mostrar correctament. L'error trobat mentre es fan les proves CUnit serà llançat per la funció 'CU_get_error()'.
El fitxer de prova CUnit anterior es desa com a fitxer mytest.c. Hem executat aquest fitxer C amb l'ordre GCC. Hem utilitzat el senyalador -lcunit per a l'execució del fitxer de prova CUnit. Amb aquesta comanda, es compila el nostre codi. A continuació, vam executar el fitxer mytest i va mostrar els resultats esperats de la prova CUnit, ja que totes les proves es van superar sense cap error.
Exemple 2
Tenim un altre exemple on hem provat els dos mètodes de gestió de fitxers, 'fread' i 'fprintf', mitjançant l'enfocament CUnit. Vam obrir i tancar el fitxer temporal mitjançant les funcions de prova CUnit. Les operacions de prova de CUnit posen a prova les funcions de la biblioteca escrivint i llegint des del fitxer temporal.
#include#inclou
#inclou
#inclou
#include 'CUnit/Basic.h'
FITXER estàtic * dossier = NULL;
int init_suite1 ( buit )
{
si ( NULL == ( dossier = fopen ( 'El meu fitxer.txt' , 'w +' ) ) ) {
tornar -1 ;
}
altra cosa {
tornar 0 ;
}
}
int clean_suite1 ( buit )
{
si ( 0 ! = f tancar ( dossier ) ) {
tornar -1 ;
}
altra cosa {
dossier = NULL;
tornar 0 ;
}
}
void test_fprintf ( buit )
{
int x1 = 10 ;
si ( NUL ! = dossier ) {
WITH_ASSERT ( 2 == fprintf ( dossier , 'Q \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( dossier , 'x1 = %d' , x1 ) ) ;
}
}
void test_fread ( buit )
{
buffer de caràcters sense signar [ 20 ] ;
si ( NUL ! = dossier ) {
rebobinar ( dossier ) ;
WITH_ASSERT ( 9 == fuig ( buffer, mida de ( caràcter sense signar ) , 20 , dossier ) ) ;
WITH_ASSERT ( 0 == strncmp ( buffer, 'Q \n x1 = 10' , 9 ) ) ;
}
}
int principal ( )
{
CU_pSuite pSuite = NULL;
si ( CUE_ÈXIT ! = CU_inicialitza_registre ( ) )
tornar CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite1' , init_suite1, clean_suite1 ) ;
si ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
si ( ( NULL == CU_add_test ( pSuite, 'Prova de la funció fprintf()' , prova_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'Prova de la funció fread()' , prova_llegir ) ) )
{
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
CU_mode_de_conjunt_bàsic ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
tornar CU_get_error ( ) ;
}
Dins del fitxer de capçalera, hem definit la biblioteca estàndard de CUnit “CUnit.h/Basic.h”. Aleshores, vam declarar 'fitxer' com a punter al fitxer utilitzat per les proves. A continuació, hem construït la funció “init_suite1” que obre el fitxer temporal “MyFile.txt” i retorna el valor zero en cas d'èxit; en cas contrari, es retornarà un valor diferent de zero. Per tancar el fitxer, hem creat la funció de neteja de la suite, que també retorna un valor diferent de zero en cas d'error mentre es tanca el fitxer temporal. En cas contrari, en tancar correctament el fitxer temporal, s'obté el valor zero. Aleshores, simplement hem implementat una funció “test_fprintf” on hem inserit les dades al fitxer temporal “MYfile.txt”. Aquestes funcions de prova també van verificar el nombre de bytes que vam intentar escriure al fitxer.
Després d'això, vam crear una altra funció per a la funció 'test_fread' per provar el mètode fread. Aquí, hem comprovat que els caràcters especificats estan presents a les dades escrites anteriorment mitjançant la funció 'test_fprinf()'. Aleshores, tenim la funció principal on es gestionen les proves configurades i executades. Hem definit la 'pSuite' a la funció principal i hem inicialitzat el registre mitjançant la funció de prova 'CU_initialize_resgistry'. També hem anomenat la funció 'CU_add_suite' per afegir la suite al registre i hem afegit les proves especificades a les suites amb l'ajuda de la funció 'CU_add_test'.
Les interfícies de prova CUnit bàsiques s'utilitzen al final per mostrar els resultats del codi. Tingueu en compte que la funció principal retorna un 'CUE_SUCCESS' quan s'executa correctament i un codi 'CUnit_error' diferent quan no s'executa correctament.
Hem executat el codi anterior per a la prova CUnit, que mostrava el resum del programa i el missatge del mètode de les proves amb èxit.
Conclusió
CUnit és un marc bàsic que proporciona diverses interfícies d'usuari. Ens permet gestionar conjunts de proves, casos de prova i registres de proves. Les interfícies d'usuari faciliten la prova dels programes i la visualització dels resultats d'aquestes proves. Hem cobert el marc de prova CUnit en C amb aquest article. Vam demostrar la instal·lació i després vam implementar dos programes en execució en llenguatge C. Els programes anteriors provats han donat resultats satisfactoris.