CUnit sistēma tiek izmantota, lai veiktu vienību testēšanu C valodā, kas ļauj administrēt un veikt testus. Tas aptver dažādus apgalvojumus, lai pārbaudītu biežāk izmantotos datu tipus, un izmanto vienkāršu arhitektūru, lai izveidotu testa struktūras. Lietotāja testēšanas kods ir saistīts ar CUnit, kas ir izveidots kā statiska bibliotēka. Mēs varam pārbaudīt C programmas uzdevumu un funkciju veiktspēju, izmantojot CUnit testa sistēmu. Katram konkrētajam C programmas uzdevumam ir atšķirīgi ievades apstākļi un izvades ierobežojumi. Lai izmantotu CUnit C programmas testēšanai, mums tas vispirms jāinstalē mūsu sistēmā. Tālāk ir aprakstītas CUnit instalēšanas darbības.
Kā izmantot CUnit ietvaru Ubuntu 22.04
Lai mūsu sistēmā izmantotu CUnit testēšanas sistēmu, mums ir jāveic instalēšanas darbības. Šīs darbības attiecas uz Ubuntu 22.04 sistēmu. Pirms instalēšanas mēs vispirms atjauninājām savu sistēmu. Sistēmai bija nepieciešamas sudo privilēģijas, lai atjauninātu ar komandu apt.
Lai iegūtu sudo privilēģijas, terminālis lūdza autentifikāciju no sudo lietotāja. Pēc tam atjauniniet sistēmas pakotnes un to atkarības, kā parādīts tālāk.
Tagad mēs esam instalējuši CUnit ietvaru, izmantojot šādu komandu. Šī komanda var instalēt pakotnes libcunitl, libcunitl-doc un libcunitl-dev no pakotņu krātuves.
Kad CUnit instalēšanas komanda ir izpildīta, ir nepieciešama lietotāja parole. CUnit būtiskās pakotnes ir instalētas mūsu Ubuntu 22.04.
1. piemērs
Iepriekšējā sadaļā mēs pabeidzām CUnit ietvara instalēšanas soli. Tagad mēs esam pārbaudījuši summas un starpības metodi, lai redzētu gaidāmos rezultātus nākamajā piemērā, izmantojot CUnit testēšanas sistēmu.
#include
#include
#include
#include
#include 'CUnit/Basic.h'
int init_suite ( nederīgs ) { atgriezties 0 ; }
int clean_suite ( nederīgs ) { atgriezties 0 ; }
int MySum ( tu esi a1, tu esi b1 )
{
int res1;
res1 =a1+b1;
atgriezties res1;
}
int MyDiff ( int a2, int b2 )
{
int res2;
res2 =a2-b2;
atgriezties res2;
}
spēkā neesošs tests_MySum ( nederīgs )
{
WITH_ASSERT ( 4 ==ManaSumma ( divi , divi ) ) ;
WITH_ASSERT ( 8 ==ManaSumma ( 5 , 3 ) ) ;
WITH_ASSERT ( divi ==ManaSumma ( - divi , 4 ) ) ;
WITH_ASSERT ( 7 ==ManaSumma ( 0 , 7 ) ) ;
}
spēkā neesošs tests_MyDiff ( nederīgs )
{
WITH_ASSERT ( 3 ==Mana atšķirība ( 5 , divi ) ) ;
WITH_ASSERT ( - 4 ==Mana atšķirība ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==Mana atšķirība ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==Mana atšķirība ( 0 , 9 ) ) ;
}
int galvenais ( nederīgs )
{
CU_pSuite pSuite1,pSuite2 = NULL;
ja ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
atgriezties CU_get_error ( ) ;
pSuite1 = CU_add_suite ( 'Test Suite1' , init_suite, clean_suite ) ;
ja ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
ja ( ( NULL == CU_add_test ( pSuite1, ' \n \n Summu funkcijas pārbaude \n \n ' , test_MySum ) ) )
{
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
ja ( ( NULL == CU_add_test ( pSuite1, ' \n \n Atšķirības funkciju pārbaude \n \n ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
Pirmkārt, lai ģenerētu CUnit struktūru, mēs esam ievietojuši CUnit bibliotēku “CUnit/Basic.h” ar iekļauto atslēgvārdu. Šī C bibliotēka ir paredzēta vienību testēšanas ietvariem un piedāvā vienkāršu konsoles izvades saskarni. Pēc tam mūsu programmai testēšanai pievienojām divas funkcijas — “init_suite” komplekta funkcijas inicializācijai un “clean_suite” komplekta funkcijas tīrīšanai.
Pēc tam mēs izveidojām metodes “MySum” un “MyDiff”, kas jāpārbauda CUnit. Mēs esam izsaukuši šo funkciju konstruktoru, kurā ir mainīgie, kuriem ir veiktas summas un starpības darbības. Tālāk mēs esam izveidojuši funkciju “test_MySum”, lai pārbaudītu. Funkcijā mēs esam izmantojuši metodi “CU_ASSERT”, kur tiek piešķirtas summas sākuma izteiksmes. Tāpat kā “test_MySum”, mēs esam izveidojuši funkciju test_MyDiff, lai pārbaudītu izteiksmi dažādām operācijām, izmantojot metodi “CU_ASSERT”.
Pēc tam galvenajā metodē ir CUnit palaidēja kods. Šeit mēs esam izveidojuši divus komplektus, “pSuite1” un “pSuite2”, no metodes “CU_pSuite” un piešķīruši šiem komplektiem NULL vērtību. Mēs esam izveidojuši šos komplektus, lai izpildītu CUnit testu, kas jāreģistrē testa reģistrā. Pirms komplektu pievienošanas “test_registry” mēs izveidojām reģistru un inicializējām to ar “ja nosacījumu”. Mēs esam izmantojuši metodi “CU_initialze_registry()”, lai izveidotu reģistru komplektu testēšanai.
Pēc tam mēs pievienojām pSuite1 testa reģistram, izsaucot CUnit metodi “CU_add_suite”. Pēc tam mēs pievienojām savus testus “test_MySum” un “test_MyDiff” norādītajiem komplektiem, izmantojot metodi “CU_add_test()”. Beigās mēs parādījām CUnit testa rezultātus, izsaucot metodi “CU_basic_run_tests()”, un iztīrījām reģistru, kad rezultāti tika veiksmīgi parādīti. Kļūda, kas radusies, veicot CUnit testus, tiks parādīta ar funkciju “CU_get_error()”.
Iepriekšējais CUnit testa fails tiek saglabāts kā fails mytest.c. Mēs esam izpildījuši šo C failu ar GCC komandu. Mēs esam izmantojuši karogu -lcunit CUnit testa faila izpildei. Ar šo komandu mūsu kods tiek apkopots. Pēc tam mēs izpildījām mytest failu, un tas parādīja sagaidāmos CUnit testa rezultātus, jo visi testi tika izturēti bez kļūmēm.
2. piemērs
Mums ir vēl viens piemērs, kurā esam pārbaudījuši divas failu apstrādes metodes, “fread” un “fprintf”, izmantojot CUnit pieeju. Mēs atvērām un aizvērām pagaidu failu, izmantojot CUnit testa funkcijas. CUnit testa darbības pārbauda bibliotēkas funkcijas, rakstot un lasot no pagaidu faila.
#include#include
#include
#include
#include 'CUnit/Basic.h'
statisks FILE * failu = NULL;
int init_suite1 ( nederīgs )
{
ja ( NULL == ( failu = fopen ( 'MansFails.txt' , 'w +' ) ) ) {
atgriezties -1 ;
}
cits {
atgriezties 0 ;
}
}
int clean_suite1 ( nederīgs )
{
ja ( 0 ! = fclose ( failu ) ) {
atgriezties -1 ;
}
cits {
failu = NULL;
atgriezties 0 ;
}
}
spēkā neesošs test_fprintf ( nederīgs )
{
int x1 = 10 ;
ja ( NULL ! = failu ) {
WITH_ASSERT ( divi == fprintf ( failu , 'J \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( failu , 'x1 = %d' , x1 ) ) ;
}
}
spēkā neesošs test_fread ( nederīgs )
{
neparakstīts rakstzīmju buferis [ divdesmit ] ;
ja ( NULL ! = failu ) {
attīt atpakaļ ( failu ) ;
WITH_ASSERT ( 9 == baiss ( buferis, izmērsof ( neparakstīts raksts ) , divdesmit , failu ) ) ;
WITH_ASSERT ( 0 == strncmp ( buferis, 'J \n x1 = 10' , 9 ) ) ;
}
}
int galvenais ( )
{
CU_pSuite pSuite = NULL;
ja ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
atgriezties CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite1' , init_suite1, clean_suite1 ) ;
ja ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
ja ( ( NULL == CU_add_test ( pSuite, 'fprintf() funkcijas pārbaude' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'Fread() funkcijas pārbaude' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
atgriezties CU_get_error ( ) ;
}
Galvenes failā esam definējuši CUnit standarta bibliotēku “CUnit.h/Basic.h”. Pēc tam mēs deklarējām “failu” kā rādītāju uz testos izmantoto failu. Tālāk mēs esam izveidojuši funkciju “init_suite1”, kas atver pagaidu failu “MyFile.txt” un atgriež vērtību nulle, ja tas ir izdevies; pretējā gadījumā tiks atgriezta vērtība, kas nav nulle. Lai aizvērtu failu, esam izveidojuši komplekta tīrīšanas funkciju, kas arī atgriež vērtību, kas nav nulle, ja pagaidu fails tiek aizvērts. Pretējā gadījumā, veiksmīgi aizverot pagaidu failu, tiek iegūta nulles vērtība. Pēc tam mēs vienkārši esam ieviesuši funkciju “test_fprintf”, kurā esam ievietojuši datus pagaidu failā “MYfile.txt”. Šīs pārbaudes funkcijas arī pārbaudīja baitu skaitu, ko mēģinājām ierakstīt failā.
Pēc tam mēs izveidojām citu funkciju funkcijai “test_fread”, lai pārbaudītu fread metodi. Šeit mēs esam pārbaudījuši, vai norādītās rakstzīmes atrodas iepriekš ierakstītajos datos, izmantojot funkciju “test_fprinf()”. Pēc tam mums ir galvenā funkcija, kurā tiek apstrādāti iestatītie un izpildītie testi. Mēs definējām “pSuite” galvenajā funkcijā un inicializējām reģistru, izmantojot testa funkciju “CU_initialize_resgistry”. Mēs esam izsaukuši arī funkciju “CU_add_suite”, lai pievienotu komplektu reģistram, un komplektiem pievienojām norādītos testus, izmantojot funkciju “CU_add_test”.
CUnit pamata testa saskarnes tiek izmantotas, lai parādītu koda rezultātus. Ņemiet vērā, ka galvenā funkcija atgriež “CUE_SUCCESS” pēc veiksmīgas izpildes un citu “CUnit_error” kodu pēc neveiksmīgas izpildes.
Mēs esam izpildījuši iepriekšējo CUnit testa kodu, kurā tika parādīts programmas kopsavilkums un veiksmīgo testu metodes ziņojums.
Secinājums
CUnit ir pamata ietvars, kas nodrošina dažādas lietotāja saskarnes. Tas ļauj mums pārvaldīt testu komplektus, testa gadījumus un testu reģistrus. Programmu testēšanu un šo testu rezultātu skatīšanu atvieglo lietotāja saskarnes. Šajā rakstā mēs esam apskatījuši CUnit testa sistēmu C valodā. Mēs demonstrējām instalēšanu un pēc tam ieviesām divas darbojošās programmas C valodā. Iepriekšējās pārbaudītās programmas ir devušas veiksmīgus rezultātus.