Ang CUnit system ay ginagamit upang isagawa ang unit testing sa C, na nagbibigay-daan para sa pangangasiwa at pagpapatupad ng mga pagsubok. Sinasaklaw nito ang magkakaibang hanay ng mga assertion para sa pagsubok sa mga karaniwang ginagamit na uri ng data at gumagamit ng isang simpleng arkitektura para sa paglikha ng mga istruktura ng pagsubok. Naka-link ang testing code ng user sa CUnit, na idinisenyo bilang isang static na library. Maaari naming suriin ang pagganap ng mga gawain at paggana ng C program gamit ang balangkas ng pagsubok ng CUnit. Ang bawat partikular na gawain ng C program ay may iba't ibang mga pangyayari sa pag-input at mga limitasyon sa output. Para magamit ang CUnit para sa pagsubok sa C program, dapat muna namin itong i-install sa aming system. Ang mga hakbang para sa pag-install ng CUnit ay nakabalangkas sa ibaba.
Paano Gamitin ang CUnit Framework sa Ubuntu 22.04
Upang magamit ang balangkas ng pagsubok ng CUnit sa aming system, kailangan naming sundin ang mga hakbang sa pag-install. Ang mga hakbang na ito ay nalalapat sa Ubuntu 22.04 system. Bago i-install, in-update muna namin ang aming system. Ang sistema ay nangangailangan ng pribilehiyo ng sudo upang ma-update gamit ang apt command.
Upang makakuha ng mga pribilehiyo ng sudo, tinanong ng terminal ang pagpapatunay mula sa gumagamit ng sudo. Pagkatapos, i-update ang mga pakete ng system at ang kanilang mga dependency, tulad ng ipinapakita sa ibaba.
Ngayon, na-install namin ang CUnit framework sa pamamagitan ng paggamit ng sumusunod na command. Maaaring i-install ng utos na ito ang mga pakete ng libunitl, libunitl-doc, at libunitl-dev mula sa imbakan ng package.
Kapag naisakatuparan na ang utos ng pag-install ng CUnit, kinakailangan ang password ng user. Ang mga mahahalagang pakete ng CUnit ay na-install sa aming Ubuntu 22.04.
Halimbawa 1
Nakumpleto namin ang hakbang sa pag-install ng balangkas ng CUnit sa nakaraang seksyon. Ngayon, sinubukan namin ang paraan ng kabuuan at pagkakaiba upang makita ang mga inaasahang resulta sa sumusunod na halimbawa gamit ang balangkas ng pagsubok ng CUnit.
#include
#include
#include
#include
#include 'CUnit/Basic.h'
int init_suite ( walang bisa ) { bumalik 0 ; }
int clean_suite ( walang bisa ) { bumalik 0 ; }
int MySum ( ikaw ay a1, ikaw ay b1 )
{
int res1;
res1 =a1+b1;
bumalik res1;
}
int MyDiff ( int a2, int b2 )
{
int res2;
res2 =a2-b2;
bumalik res2;
}
void test_MySum ( walang bisa )
{
WITH_ASSERT ( 4 ==MySum ( dalawa , dalawa ) ) ;
WITH_ASSERT ( 8 ==MySum ( 5 , 3 ) ) ;
WITH_ASSERT ( dalawa ==MySum ( - dalawa , 4 ) ) ;
WITH_ASSERT ( 7 ==MySum ( 0 , 7 ) ) ;
}
void test_MyDiff ( walang bisa )
{
WITH_ASSERT ( 3 ==MyDiff ( 5 , dalawa ) ) ;
WITH_ASSERT ( - 4 ==MyDiff ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==MyDiff ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==MyDiff ( 0 , 9 ) ) ;
}
int pangunahing ( walang bisa )
{
CU_pSuite pSuite1,pSuite2 = NULL;
kung ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
bumalik CU_get_error ( ) ;
pSuite1 = CU_add_suite ( 'Test Suite1' , init_suite, clean_suite ) ;
kung ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
kung ( ( NULL == CU_add_test ( pSuite1, ' \n \n Pagsubok ng sum function \n \n ' , test_MySum ) ) )
{
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
kung ( ( NULL == CU_add_test ( pSuite1, ' \n \n Pagsubok ng function ng pagkakaiba \n \n ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
Una, para buuin ang istruktura ng CUnit, inilagay namin ang library ng CUnit na 'CUnit/Basic.h' na may kasamang keyword. Ang C library na ito ay para sa unit testing frameworks at nag-aalok ng simpleng console output interface. Pagkatapos ay nagdagdag kami ng dalawang function, 'init_suite' para sa pagsisimula ng suite function at 'clean_suite' para sa paglilinis ng suite function, sa aming programa para sa pagsubok.
Susunod, gumawa kami ng mga pamamaraan, 'MySum' at 'MyDiff', na susuriin ng CUnit. Tinawag namin ang constructor para sa mga function na ito, na nagtataglay ng mga variable kung saan isinagawa ang mga operasyon ng kabuuan at pagkakaiba. Susunod, nagtayo kami ng isang function bilang 'test_MySum' upang subukan. Sa loob ng function, ginamit namin ang 'CU_ASSERT' na pamamaraan, kung saan ang mga init na expression para sa kabuuan ay itinalaga. Kapareho ng 'test_MySum', binuo namin ang function na test_MyDiff upang subukan ang expression para sa iba't ibang mga operasyon gamit ang 'CU_ASSERT' na paraan.
Pagkatapos, mayroon kaming CUnit runner code sa loob ng pangunahing pamamaraan. Dito, gumawa kami ng dalawang suite, 'pSuite1' at 'pSuite2', mula sa 'CU_pSuite' na paraan at itinalaga ang mga suite na ito ng NULL na halaga. Ginawa namin ang mga suite na ito para isagawa ang CUnit test na dapat na nakarehistro sa test registry. Bago idagdag ang mga suite sa 'test_registry', ginawa namin ang registry at sinimulan ito ng 'kung kundisyon'. Ginamit namin ang 'CU_initialze_registry()' na paraan para sa paggawa ng registry para sa mga testing suite.
Pagkatapos noon, idinagdag namin ang pSuite1 sa test registry sa pamamagitan ng paggamit ng 'CU_add_suite' na paraan ng CUnit. Pagkatapos noon, idinagdag namin ang aming mga pagsubok, 'test_MySum' at 'test_MyDiff', sa mga tinukoy na suite sa pamamagitan ng paggamit ng 'CU_add_test()' na paraan. Sa huli, ipinakita namin ang mga resulta ng CUnit test sa pamamagitan ng pagtawag sa 'CU_basic_run_tests()' na paraan at nilinis ang registry kapag matagumpay na naipakita ang mga resulta. Ang error na naranasan habang ginagawa ang CUnit test ay itatapon ng 'CU_get_error()' function.
Ang nakaraang CUnit test file ay nai-save bilang mytest.c file. Naisagawa namin ang C file na ito gamit ang GCC command. Ginamit namin ang -lcunit flag para sa CUnit test file execution. Sa utos na ito, ang aming code ay pinagsama-sama. Pagkatapos, isinagawa namin ang mytest file, at ipinakita nito ang inaasahang resulta ng CUnit test dahil naipasa ang lahat ng pagsubok nang walang anumang pagkabigo.
Halimbawa 2
Mayroon kaming isa pang halimbawa kung saan sinubukan namin ang dalawang paraan ng paghawak ng file, 'fread' at 'fprintf', sa pamamagitan ng CUnit approach. Binuksan at isinara namin ang pansamantalang file gamit ang CUnit test functions. Sinusubukan ng mga operasyon ng pagsubok ng CUnit ang mga function ng library sa pamamagitan ng pagsusulat at pagbabasa mula sa pansamantalang file.
#include#include
#include
#include
#include 'CUnit/Basic.h'
static na FILE * file = NULL;
int init_suite1 ( walang bisa )
{
kung ( NULL == ( file = fopen ( 'MyFile.txt' , 'w +' ) ) ) {
bumalik -1 ;
}
iba pa {
bumalik 0 ;
}
}
int clean_suite1 ( walang bisa )
{
kung ( 0 ! = fclose ( file ) ) {
bumalik -1 ;
}
iba pa {
file = NULL;
bumalik 0 ;
}
}
void test_fprintf ( walang bisa )
{
int x1 = 10 ;
kung ( WALA ! = file ) {
WITH_ASSERT ( dalawa == fprintf ( file , 'Q \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( file , 'x1 = %d' , x1 ) ) ;
}
}
void test_fread ( walang bisa )
{
unsigned char buffer [ dalawampu ] ;
kung ( WALA ! = file ) {
i-rewind ( file ) ;
WITH_ASSERT ( 9 == takot ( buffer, laki ng ( unsigned char ) , dalawampu , file ) ) ;
WITH_ASSERT ( 0 == strncmp ( buffer, 'Q \n x1 = 10' , 9 ) ) ;
}
}
int pangunahing ( )
{
CU_pSuite pSuite = NULL;
kung ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
bumalik CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite1' , init_suite1, clean_suite1 ) ;
kung ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
kung ( ( NULL == CU_add_test ( pSuite, 'Fprintf() function Test' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'Fread() function Test' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
bumalik CU_get_error ( ) ;
}
Sa loob ng header file, tinukoy namin ang CUnit standard library na 'CUnit.h/Basic.h'. Pagkatapos, idineklara namin ang 'file' bilang isang pointer sa file na ginamit ng mga pagsubok. Susunod, binuo namin ang function na 'init_suite1' na nagbubukas ng pansamantalang file na 'MyFile.txt' at ibinabalik ang halagang zero sa tagumpay; kung hindi, isang hindi-zero na halaga ang ibabalik. Upang isara ang file, ginawa namin ang function ng paglilinis ng suite, na nagbabalik din ng hindi zero na halaga sa pagkabigo habang isinasara ang pansamantalang file. Kung hindi, sa matagumpay na pagsasara ng pansamantalang file, makukuha ang zero value. Pagkatapos, ipinatupad lang namin ang isang function na 'test_fprintf' kung saan naipasok namin ang data sa pansamantalang file na 'MYfile.txt'. Na-verify din ng mga test function na ito ang bilang ng mga byte na sinubukan naming isulat sa file.
Pagkatapos noon, gumawa kami ng isa pang function para sa function na 'test_fread' upang subukan ang paraan ng fread. Dito, nasuri namin na ang mga tinukoy na character ay naroroon sa dati nang nakasulat na data ng function na 'test_fprinf()'. Pagkatapos, mayroon kaming pangunahing pag-andar kung saan ang mga pagsubok na na-set up at naisakatuparan ay pinangangasiwaan. Tinukoy namin ang 'pSuite' sa pangunahing function at sinimulan ang registry gamit ang function ng pagsubok na 'CU_initialize_resgistry'. Tinawag din namin ang function na 'CU_add_suite' upang idagdag ang suite sa registry at idinagdag ang mga tinukoy na pagsubok sa mga suite sa tulong ng function na 'CU_add_test'.
Ang mga pangunahing CUnit test interface ay ginagamit sa dulo upang ipakita ang mga resulta ng code. Tandaan na ang pangunahing function ay nagbabalik ng 'CUE_SUCCESS' sa matagumpay na pagpapatupad at ng ibang 'CUnit_error' code sa hindi matagumpay na pagpapatupad.
Pinatakbo namin ang nakaraang code para sa CUnit test, na nagpakita ng buod ng programa at ang mensahe ng paraan ng matagumpay na pagsubok.
Konklusyon
Ang CUnit ay isang pangunahing balangkas na nagbibigay ng iba't ibang mga interface ng gumagamit. Nagbibigay-daan ito sa amin na pamahalaan ang mga test suite, test case, at test registries. Ang pagsubok sa mga programa at makita ang mga resulta ng mga pagsubok na iyon ay ginagawang mas madali ng mga user interface. Sinaklaw namin ang balangkas ng pagsubok ng CUnit sa C sa artikulong ito. Ipinakita namin ang pag-install at pagkatapos ay ipinatupad ang dalawang tumatakbong programa sa wikang C. Ang mga nakaraang programang nasubok ay nagbigay ng matagumpay na resulta.