CUunitatea în C

Cuunitatea In C



Sistemul CUnit este utilizat pentru efectuarea testării unitare în C, ceea ce permite administrarea și executarea testelor. Acesta acoperă o gamă diversă de afirmații pentru testarea tipurilor de date utilizate în mod obișnuit și utilizează o arhitectură simplă pentru crearea structurilor de testare. Codul de testare al utilizatorului este legat de CUnit, care este conceput ca o bibliotecă statică. Putem examina performanța sarcinilor și funcțiilor programului C folosind cadrul de testare CUnit. Fiecare sarcină particulară a programului C are circumstanțe diferite de intrare și limitări de ieșire. Pentru a folosi CUnit pentru a testa programul C, ar trebui să îl instalăm mai întâi în sistemul nostru. Pașii pentru instalarea CUnit sunt prezentați mai jos.

Cum să utilizați cadrul CUnit în Ubuntu 22.04

Pentru a utiliza cadrul de testare CUnit în sistemul nostru, trebuie să urmăm pașii de instalare. Acești pași se aplică sistemului Ubuntu 22.04. Înainte de instalare, ne-am actualizat mai întâi sistemul. Sistemul necesita privilegii sudo pentru a fi actualizat cu comanda apt.








Pentru a obține privilegii sudo, terminalul a cerut autentificarea utilizatorului sudo. Apoi, actualizați pachetele de sistem și dependențele acestora, așa cum se arată mai jos.




Acum, am instalat cadrul CUnit folosind următoarea comandă. Această comandă poate instala pachetele libcunitl, libcunitl-doc și libcunitl-dev din depozitul de pachete.




Odată ce comanda de instalare CUnit este executată, este necesară parola de utilizator. Pachetele esențiale CUnit au fost instalate în Ubuntu 22.04.





Exemplul 1

Am finalizat pasul de instalare a cadrului CUnit în secțiunea anterioară. Acum, am testat metoda sumei și diferențelor pentru a vedea rezultatele așteptate în exemplul următor folosind cadrul de testare CUnit.



#include
#include <șir.h>
#include
#include <șir.h>
#include „CUnit/Basic.h”

int init_suite ( gol ) { întoarcere 0 ; }
int clean_suite ( gol ) { întoarcere 0 ; }

int Suma mea ( esti a1, esti b1 )

{
int res1;
res1 =a1+b1;
întoarcere res1;
}

int MyDiff ( int a2, int b2 )

{
int res2;
res2 =a2-b2;
întoarcere res2;
}

void test_MySum ( gol )
{
CU_ASSERT ( 4 ==MySum ( Două , Două ) ) ;
CU_ASSERT ( 8 ==MySum ( 5 , 3 ) ) ;
CU_ASSERT ( Două ==MySum ( - Două , 4 ) ) ;
CU_ASSERT ( 7 ==MySum ( 0 , 7 ) ) ;
}


void test_MyDiff ( gol )
{
CU_ASSERT ( 3 ==MyDiff ( 5 , Două ) ) ;
CU_ASSERT ( - 4 ==MyDiff ( 4 , 8 ) ) ;
CU_ASSERT ( - 7 ==MyDiff ( - 3 , 4 ) ) ;
CU_ASSERT ( - 9 ==MyDiff ( 0 , 9 ) ) ;
}


int principal ( gol )
{

CU_pSuite pSuite1,pSuite2 = NULL;

dacă ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
întoarcere CU_get_error ( ) ;

pSuite1 = CU_add_suite ( „Test Suite1” , init_suite, clean_suite ) ;
dacă ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}

dacă ( ( NULL == CU_add_test ( pSuite1, ' \n \n Funcția de sumă Testare \n \n ' , test_MySum ) ) )
{
CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}

dacă ( ( NULL == CU_add_test ( pSuite1, ' \n \n Funcția de diferență Testare \n \n ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}

CU_basic_run_tests ( ) ;

CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}







Mai întâi, pentru a genera structura CUnit, am inserat biblioteca CUnit „CUnit/Basic.h” cu cuvântul cheie inclus. Această bibliotecă C este pentru cadrele de testare unitară și oferă o interfață simplă de ieșire pentru consolă. Apoi am adăugat două funcții, „init_suite” pentru inițializarea funcției suite și „clean_suite” pentru curățarea funcției suite, la programul nostru de testare.

Apoi, am construit metode, „MySum” și „MyDiff”, pentru a fi testate de CUnit. Am numit constructorul pentru aceste funcții, care deține variabilele pe care au fost efectuate operațiile de sumă și diferență. Apoi, am stabilit o funcție ca „test_MySum” pentru a testa. În interiorul funcției, am folosit metoda „CU_ASSERT”, în care sunt atribuite expresiile inițiale pentru sumă. La fel ca „test_MySum”, am construit funcția test_MyDiff pentru a testa expresia pentru diferite operații folosind metoda „CU_ASSERT”.

Apoi, avem codul de rulare CUnit în cadrul metodei principale. Aici, am creat două suite, „pSuite1” și „pSuite2”, din metoda „CU_pSuite” și le-am atribuit acestor suite o valoare NULL. Am creat aceste suite pentru a executa testul CUnit care ar trebui să fie înregistrat în registrul de teste. Înainte de a adăuga suitele la „test_registry”, am creat registrul și l-am inițializat cu „condiția dacă”. Am folosit metoda „CU_initialze_registry()” pentru a crea registrul pentru suitele de testare.

După aceea, am adăugat pSuite1 la registrul de testare invocând metoda „CU_add_suite” a CUnit. După aceea, am adăugat testele noastre, „test_MySum” și „test_MyDiff”, la suitele specificate, utilizând metoda „CU_add_test()”. La final, am afișat rezultatele testului CUnit apelând metoda „CU_basic_run_tests()” și am curățat registry odată ce rezultatele au fost afișate cu succes. Eroarea întâlnită la efectuarea testelor CUnit va fi aruncată de funcția „CU_get_error()”.

Fișierul de testare CUnit anterior este salvat ca fișierul mytest.c. Am executat acest fișier C cu comanda GCC. Am folosit indicatorul -lcunit pentru executarea fișierului de testare CUnit. Cu această comandă, codul nostru este compilat. Apoi, am executat fișierul mytest și a arătat rezultatele așteptate ale testului CUnit, deoarece toate testele au fost trecute fără niciun eșec.

Exemplul 2

Avem un alt exemplu în care am testat cele două metode de gestionare a fișierelor, „fread” și „fprintf”, prin abordarea CUnit. Am deschis și închis fișierul temporar folosind funcțiile de testare CUnit. Operațiile de testare CUnit testează funcțiile bibliotecii prin scrierea și citirea din fișierul temporar.

#include
#include <șir.h>
#include
#include <șir.h>
#include „CUnit/Basic.h”

FIȘIER static * fişier = NULL;
int init_suite1 ( gol )
{
dacă ( NULL == ( fişier = fopen ( „MyFile.txt” , 'w +' ) ) ) {
întoarcere -1 ;
}
altfel {
întoarcere 0 ;
}
}

int clean_suite1 ( gol )
{
dacă ( 0 ! = fclose ( fişier ) ) {
întoarcere -1 ;
}
altfel {
fişier = NULL;
întoarcere 0 ;
}
}


void test_fprintf ( gol )
{
int x1 = 10 ;

dacă ( NUL ! = fişier ) {
      CU_ASSERT ( Două == fprintf ( fişier , „Î \n ' ) ) ;
      CU_ASSERT ( 7 == fprintf ( fişier , 'x1 = %d' , x1 ) ) ;
}
}

void test_fread ( gol )
{
buffer de caracter nesemnat [ douăzeci ] ;

dacă ( NUL ! = fişier ) {
derulează înapoi ( fişier ) ;
      CU_ASSERT ( 9 == frid ( tampon, dimensiunea ( nesemnat char ) , douăzeci , fişier ) ) ;
      CU_ASSERT ( 0 == strncmp ( tampon, „Î \n x1 = 10' , 9 ) ) ;
}
}

int principal ( )
{
   CU_pSuite pSuite = NULL;
dacă ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
întoarcere CU_get_error ( ) ;
pSuite = CU_add_suite ( „Suita 1” , init_suite1, clean_suite1 ) ;
dacă ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}
dacă ( ( NULL == CU_add_test ( pSuită, „Testul funcției fprintf()” , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuită, „Testul funcției fread()” , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
întoarcere CU_get_error ( ) ;
}







În cadrul fișierului antet, am definit biblioteca standard CUnit „CUnit.h/Basic.h”. Apoi, am declarat „fișier” ca un pointer către fișierul folosit de teste. Apoi, am construit funcția „init_suite1” care deschide fișierul temporar „MyFile.txt” și returnează valoarea zero la succes; în caz contrar, va fi returnată o valoare diferită de zero. Pentru a închide fișierul, am creat funcția de curățare a suitei, care returnează și o valoare diferită de zero la eșec în timpul închiderii fișierului temporar. În caz contrar, la închiderea cu succes a fișierului temporar, se obține valoarea zero. Apoi, pur și simplu am implementat o funcție „test_fprintf” în care am inserat datele în fișierul temporar „MYfile.txt”. Aceste funcții de testare au verificat și numărul de octeți pe care am încercat să-i scriem în fișier.

După aceea, am creat o altă funcție pentru funcția „test_fread” pentru a testa metoda fread. Aici, am verificat dacă caracterele specificate sunt prezente în datele scrise anterior de către funcția „test_fprinf()”. Apoi, avem funcția principală în care sunt gestionate testele configurate și executate. Am definit „pSuite” în funcția principală și am inițializat registry folosind funcția de testare „CU_initialize_resgistry”. Am numit și funcția „CU_add_suite” pentru a adăuga suita în registry și am adăugat testele specificate la suite cu ajutorul funcției „CU_add_test”.

Interfețele de testare CUnit de bază sunt utilizate în final pentru a afișa rezultatele codului. Rețineți că funcția principală returnează un „CUE_SUCCESS” la execuția cu succes și un alt cod „CUnit_error” la o execuție nereușită.

Am rulat codul anterior pentru testul CUnit, care a afișat rezumatul programului și mesajul metodei testelor reușite.

Concluzie

CUnit este un cadru de bază care oferă diverse interfețe de utilizator. Ne permite să gestionăm suite de testare, cazuri de testare și registre de testare. Testarea programelor și vizualizarea rezultatelor acestor teste este ușoară de interfețele utilizatorului. Am acoperit cadrul de testare CUnit în C cu acest articol. Am demonstrat instalarea și apoi am implementat două programe care rulează în limbaj C. Programele precedente testate au dat rezultate de succes.