CUnit i c

CUnit -systemet brukes til å utføre enhetstestingen i C, som muliggjør administrering og utførelse av testene. Det dekker et mangfoldig utvalg av påstander for testing ofte brukte datatyper og bruker en enkel arkitektur for å lage teststrukturer. Brukerens testkode er koblet med CUnit, som er designet som et statisk bibliotek. Vi kan undersøke ytelsen til C -programmets oppgaver og funksjoner ved hjelp av CUnit Test Framework. Hver spesiell oppgave med C -programmet har forskjellige inngangsforhold og utgangsbegrensninger. For å bruke CUnit for å teste C -programmet, bør vi installere det først i systemet vårt. Trinnene for å installere CUnit er skissert nedenfor.

Hvordan bruke CUnit -rammen i Ubuntu 22.04

For å bruke CUnit Testing Framework i systemet vårt, må vi følge installasjonstrinnene. Disse trinnene gjelder Ubuntu 22.04 System. Før installasjonen oppdaterte vi først systemet vårt. Systemet krevde sudo -privilegium for å bli oppdatert med APT -kommandoen.

For å skaffe sudo -privilegier, spurte terminalen autentiseringen fra sudo -brukeren. Oppdater deretter systempakkene og deres avhengigheter, som vist nedenfor.

Nå har vi installert CUnit -rammeverket ved å bruke følgende kommando. Denne kommandoen kan installere libcunitl, libcunitl-doc og libcunitl-dev-pakkene fra pakkelageret.

Når CUnit -installasjonskommandoen er utført, er brukerpassordet påkrevd. CUnit Essential Packages er installert i Ubuntu 22.04.

Eksempel 1

Vi fullførte installasjonstrinnet i CUnit -rammeverket i forrige seksjon. Nå har vi testet summen og forskjellsmetoden for å se de forventede resultatene i følgende eksempel ved bruk av CUnit Testing Framework.

#inkludere
#inkludere
#inkludere
#inkludere
#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;
Retur Res1;

Int mydiff (int a2, int b2)

int res2;
Res2 = A2-B2;
Retur Res2;

void test_mysum (ugyldig)

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 (Void)

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 funksjonstesting \ n \ n", test_mysum))))

Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite1, "\ n \ ndiffence funksjonstesting \ n \ n", test_mydiff))))

Cu_cleanup_registry ();
return cu_get_error ();

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

For det første, for å generere CUnit -strukturen, har vi satt inn CUnit -biblioteket “CUNIT/BASIC.H ”med det inkluderte nøkkelordet. Dette C -biblioteket er for enhetstestingsrammer og tilbyr et enkelt konsollutgangsgrensesnitt. Deretter la vi til to funksjoner, "init_suite" for initialiseringen av suitefunksjonen og "Clean_suite" for opprydding av suite -funksjonen, til vårt program for testing.

Deretter konstruerte vi metoder, "mysum" og "mydiff", som skal testes av CUnit. Vi har ringt konstruktøren for disse funksjonene, som inneholder variablene som sum og forskjellsoperasjoner er utført. Deretter har vi etablert en funksjon som "test_mysum" for å teste. Inne i funksjonen har vi benyttet oss. Samme som “Test_mysum”, har vi konstruert test_mydiff -funksjonen for å teste uttrykket for forskjellige operasjoner ved hjelp av “cu_assert” -metoden.

Deretter har vi CUnit Runner -koden i hovedmetoden. Her har vi laget to suiter, “Psuite1” og “Psuite2”, fra “CU_PSUITE” -metoden og tildelt disse suitene en nullverdi. Vi har laget disse suitene for å utføre CUnit -testen som bør registreres i testregisteret. Før vi la suitene til "Test_registry", opprettet vi registeret og initialiserte det med "hvis tilstand". Vi har brukt “CU_INITIALZE_REGISTRY ()” -metoden for å lage registeret for å teste suiter.

Etter det la vi Psuite1 til testregisteret ved å påkalle "cu_add_suite" -metoden til CUnit. Etter det la vi til testene våre, “test_mysum” og “test_mydiff”, til de spesifiserte suitene ved å bruke metoden “cu_add_test ()”. Til slutt viste vi resultatene fra CUnit -testen ved å kalle metoden “cu_basic_run_tests ()” og renset registeret når resultatene ble vist vellykket. Feilen som oppstår mens du gjør CUnit -testene, vil bli kastet av "CU_GET_ERROR ()" -funksjonen.

Den forrige CUNIT -testfilen lagres som Mytest.C -fil. Vi har utført denne C -filen med GCC -kommandoen. Vi har brukt -LCUnit Flag for CuNit Test File Execution. Med denne kommandoen er koden vår samlet. Deretter utførte vi Mytest -filen, og den viste de forventede resultatene av CUnit -testen da alle testene ble bestått uten noen feil.

Eksempel 2

Vi har et annet eksempel der vi har testet de to filhåndteringsmetodene, "Fread" og "Fprintf", etter CUnit -tilnærmingen. Vi åpnet og lukket den midlertidige filen ved hjelp av CUnit -testfunksjonene. CUnit -testoperasjonene tester biblioteket fungerer ved å skrive og lese fra den midlertidige filen.

#inkludere
#inkludere
#inkludere
#inkludere
#include "CUnit/Basic.h "
statisk fil* fil = null;
int init_suite1 (tomrom)

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

annet
retur 0;


int clean_suite1 (tomrom)

hvis (0 != fClose (fil))
return -1;

annet
fil = null;
retur 0;


void test_fprintf (void)

int x1 = 10;
hvis (null != fil)
Cu_assert (2 == fprintf (fil, "q \ n"));
Cu_assert (7 == fprintf (fil, "x1 = %d", x1));


void test_fread (void)

usignert røye buffer [20];
hvis (null != fil)
spole tilbake (fil);
Cu_assert (9 == FREAD (buffer, størrelse av (usignert røye), 20, fil));
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, "fprintf () funksjonstest", test_fprintf)) ||
(Null == cu_add_test (psuite, "fread () funksjonstest", 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 ();

Innenfor overskriftsfilen har vi definert CUnit Standard Library “CUnit.h/grunnleggende.h ”. Deretter erklærte vi "fil" som en peker til filen som ble brukt av testene. Deretter har vi konstruert "init_suite1" -funksjonen som åpner den midlertidige filen "myfile.txt ”og returnerer verdien null på suksess; Ellers vil en ikke-null verdi bli returnert. For å lukke filen har vi opprettet Suite Cleanup-funksjonen, som også returnerer en verdi som ikke er null ved feil mens vi lukker den midlertidige filen. Ellers, når du lukker den midlertidige filen, oppnås nullverdi. Deretter har vi ganske enkelt implementert en funksjon “TEST_FPRINTF” der vi har satt inn dataene i den midlertidige filen “MyFile.tekst". Disse testfunksjonene bekreftet også antall byte som vi forsøkte å skrive i filen.

Etter det opprettet vi en annen funksjon for "Test_Fread" -funksjonen for å teste Fread -metoden. Her har vi sjekket at de spesifiserte tegnene er til stede i de tidligere skriftlige dataene fra "Test_Fprinf ()" -funksjonen. Deretter har vi hovedfunksjonen der testene som er satt opp og utført blir håndtert. Vi definerte “Psuite” i hovedfunksjonen og initialiserte registeret ved å bruke testfunksjonen “cu_initialize_resgistry”. Vi har også kalt "CU_ADD_SUITE" -funksjonen for å legge suiten til registeret og lagt til de spesifiserte testene til suitene ved hjelp av "cu_add_test" -funksjonen.

De grunnleggende CUnit -testgrensesnittene brukes til slutt for å vise resultatene av koden. Merk at hovedfunksjonen returnerer en "cue_success" ved vellykket utførelse og en annen "cunit_error" -kode ved mislykket utførelse.

Vi har kjørt den forrige koden for CUnit -testen, som viste programmets sammendrag og den vellykkede testens metodemelding.

Konklusjon

CUnit er et kjerneramme som gir forskjellige brukergrensesnitt. Det lar oss administrere testsuiter, testsaker og testregistre. Testing av programmene og se resultatene fra disse testene blir gjort enklere av brukergrensesnittene. Vi har dekket CUnit Test Framework i C med denne artikkelen. Vi demonstrerte installasjonen og implementerte deretter to løpsprogrammer på C -språk. De tidligere testede programmene har gitt vellykkede resultater.