CEnhed i C

Cenhed I C



CUnit-systemet bruges til at udføre enhedstesten i C, som muliggør administration og udførelse af testene. Den dækker en bred vifte af påstande til test af almindeligt anvendte datatyper og bruger en simpel arkitektur til at skabe teststrukturer. Brugerens testkode er forbundet med CUnit, som er designet som et statisk bibliotek. Vi kan undersøge udførelsen af ​​C-programmets opgaver og funktioner ved hjælp af CUnit-testrammerne. Hver bestemt opgave i C-programmet har forskellige input-forhold og output-begrænsninger. For at bruge CUnit til at teste C-programmet, bør vi installere det først i vores system. Trinene til installation af CUnit er beskrevet nedenfor.

Sådan bruges CUnit-rammen i Ubuntu 22.04

For at bruge CUnit-testrammerne i vores system skal vi følge installationstrinnene. Disse trin gælder for Ubuntu 22.04-systemet. Før installationen opdaterede vi først vores system. Systemet krævede sudo-privilegium for at blive opdateret med kommandoen apt.








For at erhverve sudo-privilegier bad terminalen om autentificeringen fra sudo-brugeren. Opdater derefter systempakkerne og deres afhængigheder, som vist nedenfor.




Nu har vi installeret CUnit-rammeværket ved at bruge følgende kommando. Denne kommando kan installere pakkerne libcunitl, libcunitl-doc og libcunitl-dev fra pakkelageret.




Når CUnit-installationskommandoen er udført, kræves brugeradgangskoden. De essentielle CUnit-pakker er blevet installeret i vores Ubuntu 22.04.





Eksempel 1

Vi fuldførte installationstrinnet af CUnit-rammerne i det foregående afsnit. Nu har vi testet sum- og differencemetoden for at se de forventede resultater i følgende eksempel ved hjælp af CUnit-testrammerne.



#include
#include
#include
#include
#include 'CUnit/Basic.h'

int init_suite ( ugyldig ) { Vend tilbage 0 ; }
int clean_suite ( ugyldig ) { Vend tilbage 0 ; }

int MySum ( du er a1, du er b1 )

{
int res1;
res1 =a1+bl;
Vend tilbage res1;
}

int MyDiff ( int a2, int b2 )

{
int res2;
res2 =a2-b2;
Vend tilbage res2;
}

void test_MySum ( ugyldig )
{
WITH_ASSERT ( 4 ==Min Sum ( to , to ) ) ;
WITH_ASSERT ( 8 ==Min Sum ( 5 , 3 ) ) ;
WITH_ASSERT ( to ==Min Sum ( - to , 4 ) ) ;
WITH_ASSERT ( 7 ==Min Sum ( 0 , 7 ) ) ;
}


void test_MyDiff ( ugyldig )
{
WITH_ASSERT ( 3 ==MyDiff ( 5 , to ) ) ;
WITH_ASSERT ( - 4 ==MyDiff ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==MyDiff ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==MyDiff ( 0 , 9 ) ) ;
}


int main ( ugyldig )
{

CU_pSuite pSuite1,pSuite2 = NULL;

hvis ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
Vend tilbage CU_get_error ( ) ;

pSuite1 = CU_add_suite ( 'Test Suite1' , init_suite, clean_suite ) ;
hvis ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}

hvis ( ( NULL == CU_add_test ( pSuite1, ' \n \n Sum funktionstest \n \n ' , test_MinSum ) ) )
{
CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}

hvis ( ( NULL == CU_add_test ( pSuite1, ' \n \n Forskel funktionstest \n \n ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}

CU_basic_run_tests ( ) ;

CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}







For det første, for at generere CUnit-strukturen, har vi indsat CUnit-biblioteket 'CUnit/Basic.h' med det inkluderede nøgleord. Dette C-bibliotek er til enhedstestrammer og tilbyder en enkel konsoludgangsgrænseflade. Derefter tilføjede vi to funktioner, 'init_suite' til initialisering af suite-funktionen og 'clean_suite' til oprydning af suite-funktionen, til vores program til test.

Dernæst konstruerede vi metoder, 'MySum' og 'MyDiff', som skulle testes af CUnit. Vi har kaldt konstruktøren for disse funktioner, som rummer de variable, som sum- og differensoperationer er blevet udført på. Dernæst har vi etableret en funktion som 'test_MySum' for at teste. Inde i funktionen har vi brugt metoden 'CU_ASSERT', hvor init-udtrykkene for summen er tildelt. Samme som 'test_MySum', har vi konstrueret test_MyDiff-funktionen for at teste udtrykket for forskellige operationer ved hjælp af 'CU_ASSERT'-metoden.

Så har vi CUnit-løberkoden inde i hovedmetoden. Her har vi lavet to suiter, 'pSuite1' og 'pSuite2', fra 'CU_pSuite'-metoden og tildelt disse suiter en NULL-værdi. Vi har oprettet disse suiter for at udføre CUnit-testen, der skal registreres i testregistret. Før vi tilføjede suiterne til 'test_registry', oprettede vi registreringsdatabasen og initialiserede den med 'if condition'. Vi har brugt 'CU_initialze_registry()'-metoden til at oprette registreringsdatabasen til testsuiter.

Derefter føjede vi pSuite1 til testregistret ved at påberåbe CU_add_suite-metoden i CUnit. Derefter tilføjede vi vores test, 'test_MySum' og 'test_MyDiff', til de angivne suiter ved at bruge 'CU_add_test()'-metoden. Til sidst viste vi resultaterne af CUnit-testen ved at kalde metoden 'CU_basic_run_tests()' og rensede registreringsdatabasen, når resultaterne blev vist med succes. Fejlen, der opstod under udførelsen af ​​CUnit-testene, vil blive kastet af funktionen 'CU_get_error()'.

Den tidligere CUnit-testfil gemmes som mytest.c-filen. Vi har udført denne C-fil med GCC-kommandoen. Vi har brugt flaget -lcunit til udførelse af CUnit-testfil. Med denne kommando kompileres vores kode. Derefter udførte vi mytest-filen, og den viste de forventede resultater af CUnit-testen, da alle testene blev bestået uden fejl.

Eksempel 2

Vi har et andet eksempel, hvor vi har testet de to filhåndteringsmetoder, 'fread' og 'fprintf', ved hjælp af CUnit-tilgangen. Vi åbnede og lukkede den midlertidige fil ved hjælp af CUnit-testfunktionerne. CUnit-testoperationerne tester biblioteksfunktionerne ved at skrive og læse fra den midlertidige fil.

#include
#include
#include
#include
#include 'CUnit/Basic.h'

statisk FIL * fil = NULL;
int init_suite1 ( ugyldig )
{
hvis ( NULL == ( fil = fopen ( 'MyFile.txt' , 'w +' ) ) ) {
Vend tilbage -1 ;
}
andet {
Vend tilbage 0 ;
}
}

int clean_suite1 ( ugyldig )
{
hvis ( 0 ! = fnær ( fil ) ) {
Vend tilbage -1 ;
}
andet {
fil = NULL;
Vend tilbage 0 ;
}
}


void test_fprintf ( ugyldig )
{
int x1 = 10 ;

hvis ( NUL ! = fil ) {
WITH_ASSERT ( to == fprintf ( fil , 'Q \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( fil , 'x1 = %d' , x1 ) ) ;
}
}

void test_fread ( ugyldig )
{
usigneret char buffer [ tyve ] ;

hvis ( NUL ! = fil ) {
spole tilbage ( fil ) ;
WITH_ASSERT ( 9 == fread ( buffer, størrelse af ( usigneret char ) , tyve , fil ) ) ;
WITH_ASSERT ( 0 == strncmp ( buffer, 'Q \n x1 = 10' , 9 ) ) ;
}
}

int main ( )
{
CU_pSuite pSuite = NULL;
hvis ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
Vend tilbage CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite 1' , init_suite1, clean_suite1 ) ;
hvis ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}
hvis ( ( NULL == CU_add_test ( pSuite, 'fprintf() funktionstest' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'fread() funktionstest' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
Vend tilbage CU_get_error ( ) ;
}







I header-filen har vi defineret CUnit-standardbiblioteket 'CUnit.h/Basic.h'. Derefter erklærede vi 'fil' som en pegepind til den fil, der blev brugt af testene. Dernæst har vi konstrueret funktionen 'init_suite1', der åbner den midlertidige fil 'MyFile.txt' og returnerer værdien nul ved succes; ellers vil en værdi, der ikke er nul, blive returneret. For at lukke filen har vi oprettet suiteoprydningsfunktionen, som også returnerer en værdi, der ikke er nul ved fejl, mens den midlertidige fil lukkes. Ellers opnås nulværdien ved succesfuld lukning af den midlertidige fil. Så har vi simpelthen implementeret en funktion 'test_fprintf', hvor vi har indsat dataene i den midlertidige fil 'MYfile.txt'. Disse testfunktioner bekræftede også antallet af bytes, som vi forsøgte at skrive i filen.

Derefter oprettede vi en anden funktion til funktionen 'test_fread' for at teste fread-metoden. Her har vi kontrolleret, at de angivne tegn er til stede i de tidligere skrevne data ved hjælp af funktionen 'test_fprinf()'. Derefter har vi hovedfunktionen, hvor de opstillede og udførte tests håndteres. Vi definerede 'pSuite' i hovedfunktionen og initialiserede registreringsdatabasen ved hjælp af testfunktionen 'CU_initialize_reslistry'. Vi har også kaldt 'CU_add_suite'-funktionen for at tilføje suiten til registreringsdatabasen og tilføjet de specificerede tests til suiterne ved hjælp af 'CU_add_test'-funktionen.

De grundlæggende CUnit-testgrænseflader bruges til sidst til at vise resultaterne af koden. Bemærk, at hovedfunktionen returnerer en 'CUE_SUCCESS' ved vellykket udførelse og en anden 'CUnit_error' kode ved mislykket udførelse.

Vi har kørt den tidligere kode for CUnit-testen, som viste programoversigten og de vellykkede tests metodemeddelelse.

Konklusion

CUnit er en kerneramme, der giver forskellige brugergrænseflader. Det giver os mulighed for at administrere testpakker, testcases og testregistre. Det er nemmere at teste programmerne og se resultaterne af disse tests af brugergrænsefladerne. Vi har dækket CUnit-testrammerne i C med denne artikel. Vi demonstrerede installationen og implementerede derefter to kørende programmer i C-sprog. De tidligere testede programmer har givet vellykkede resultater.