CUnit వ్యవస్థ C లో యూనిట్ పరీక్షను నిర్వహించడానికి ఉపయోగించబడుతుంది, ఇది పరీక్షల నిర్వహణ మరియు అమలు కోసం అనుమతిస్తుంది. ఇది సాధారణంగా ఉపయోగించే డేటా రకాలను పరీక్షించడానికి విభిన్న శ్రేణి వాదనలను కవర్ చేస్తుంది మరియు పరీక్ష నిర్మాణాలను రూపొందించడానికి సరళమైన నిర్మాణాన్ని ఉపయోగిస్తుంది. వినియోగదారు పరీక్ష కోడ్ CUnitతో లింక్ చేయబడింది, ఇది స్టాటిక్ లైబ్రరీగా రూపొందించబడింది. మేము CUnit టెస్ట్ ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి C ప్రోగ్రామ్ యొక్క టాస్క్‌లు మరియు ఫంక్షన్‌ల పనితీరును పరిశీలించవచ్చు. C ప్రోగ్రామ్ యొక్క ప్రతి ప్రత్యేక పనికి వేర్వేరు ఇన్‌పుట్ పరిస్థితులు మరియు అవుట్‌పుట్ పరిమితులు ఉంటాయి. C ప్రోగ్రామ్‌ని పరీక్షించడానికి CUnitని ఉపయోగించడానికి, మన సిస్టమ్‌లో దీన్ని ముందుగా ఇన్‌స్టాల్ చేయాలి. CUnit ఇన్‌స్టాల్ చేసే దశలు క్రింద వివరించబడ్డాయి.
ఉబుంటు 22.04లో CUnit ఫ్రేమ్‌వర్క్‌ను ఎలా ఉపయోగించాలి
మా సిస్టమ్‌లో CUnit టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ని ఉపయోగించడానికి, మేము ఇన్‌స్టాలేషన్ దశలను అనుసరించాలి. ఈ దశలు ఉబుంటు 22.04 సిస్టమ్‌కు వర్తిస్తాయి. ఇన్‌స్టాలేషన్‌కు ముందు, మేము మొదట మా సిస్టమ్‌ను నవీకరించాము. apt కమాండ్‌తో అప్‌డేట్ కావడానికి సిస్టమ్‌కు sudo ప్రివిలేజ్ అవసరం.
సుడో అధికారాలను పొందేందుకు, టెర్మినల్ సుడో వినియోగదారు నుండి ప్రమాణీకరణను కోరింది. ఆపై, క్రింద చూపిన విధంగా సిస్టమ్ ప్యాకేజీలు మరియు వాటి డిపెండెన్సీలను నవీకరించండి.
ఇప్పుడు, మేము కింది ఆదేశాన్ని ఉపయోగించి CUnit ఫ్రేమ్‌వర్క్‌ను ఇన్‌స్టాల్ చేసాము. ఈ ఆదేశం libcunitl, libcunitl-doc, మరియు libcunitl-dev ప్యాకేజీలను ప్యాకేజీ రిపోజిటరీ నుండి సంస్థాపించగలదు.
CUnit ఇన్‌స్టాలేషన్ కమాండ్ అమలు చేయబడిన తర్వాత, వినియోగదారు పాస్‌వర్డ్ అవసరం. CUnit అవసరమైన ప్యాకేజీలు మా ఉబుంటు 22.04లో ఇన్‌స్టాల్ చేయబడ్డాయి.
ఉదాహరణ 1
మేము మునుపటి విభాగంలో CUnit ఫ్రేమ్‌వర్క్ యొక్క ఇన్‌స్టాలేషన్ దశను పూర్తి చేసాము. ఇప్పుడు, మేము CUnit టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి కింది ఉదాహరణలో ఆశించిన ఫలితాలను చూడటానికి మొత్తం మరియు వ్యత్యాస పద్ధతిని పరీక్షించాము.
#
#include
#
#include
#'CUnit/Basic.h'ని చేర్చండి
int init_suite ( శూన్యం ) { తిరిగి 0 ; }
int clean_suite ( శూన్యం ) { తిరిగి 0 ; }
int MySum ( మీరు a1, మీరు b1 )
{
int res1;
res1 =a1+b1;
తిరిగి res1;
}
int MyDiff ( int a2, int b2 )
{
int res2;
res2 =a2-b2;
తిరిగి res2;
}
శూన్య పరీక్ష_MySum ( శూన్యం )
{
WITH_ASSERT ( 4 ==MySum ( రెండు , రెండు ) ) ;
WITH_ASSERT ( 8 ==MySum ( 5 , 3 ) ) ;
WITH_ASSERT ( రెండు ==MySum ( - రెండు , 4 ) ) ;
WITH_ASSERT ( 7 ==MySum ( 0 , 7 ) ) ;
}
శూన్యం test_MyDiff ( శూన్యం )
{
WITH_ASSERT ( 3 ==MyDiff ( 5 , రెండు ) ) ;
WITH_ASSERT ( - 4 ==MyDiff ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==MyDiff ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==MyDiff ( 0 , 9 ) ) ;
}
పూర్ణాంక ప్రధాన ( శూన్యం )
{
CU_pSuite pSuite1,pSuite2 = NULL;
ఉంటే ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
తిరిగి CU_get_error ( ) ;
pSuite1 = CU_add_suite ( 'టెస్ట్ సూట్1' , init_suite, clean_suite ) ;
ఉంటే ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
ఉంటే ( ( NULL == CU_add_test ( pSuite1, ' \n \n సమ్ ఫంక్షన్ టెస్టింగ్ \n \n ' , test_MySum ) ) )
{
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
ఉంటే ( ( NULL == CU_add_test ( pSuite1, ' \n \n తేడా ఫంక్షన్ టెస్టింగ్ \n \n ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
ముందుగా, CUnit నిర్మాణాన్ని రూపొందించడానికి, మేము చేర్చబడిన కీవర్డ్‌తో CUnit లైబ్రరీ “CUnit/Basic.h”ని చొప్పించాము. ఈ C లైబ్రరీ యూనిట్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ల కోసం మరియు సాధారణ కన్సోల్ అవుట్‌పుట్ ఇంటర్‌ఫేస్‌ను అందిస్తుంది. మేము పరీక్ష కోసం మా ప్రోగ్రామ్‌కు సూట్ ఫంక్షన్‌ని ప్రారంభించడం కోసం “init_suite” మరియు సూట్ ఫంక్షన్‌ను శుభ్రపరచడం కోసం “clean_suite” అనే రెండు ఫంక్షన్‌లను జోడించాము.
తర్వాత, మేము CUnit ద్వారా పరీక్షించడానికి “MySum” మరియు “MyDiff” పద్ధతులను రూపొందించాము. మేము ఈ ఫంక్షన్‌ల కోసం కన్స్ట్రక్టర్‌ని పిలిచాము, ఇది మొత్తం మరియు వ్యత్యాస కార్యకలాపాలు నిర్వహించబడే వేరియబుల్‌లను కలిగి ఉంటుంది. తర్వాత, మేము పరీక్షించడానికి “test_MySum”గా ఒక ఫంక్షన్‌ని ఏర్పాటు చేసాము. ఫంక్షన్ లోపల, మేము “CU_ASSERT” పద్ధతిని ఉపయోగించాము, ఇక్కడ మొత్తానికి init వ్యక్తీకరణలు కేటాయించబడతాయి. “test_MySum” వలె, మేము “CU_ASSERT” పద్ధతిని ఉపయోగించి వివిధ కార్యకలాపాల కోసం వ్యక్తీకరణను పరీక్షించడానికి test_MyDiff ఫంక్షన్‌ని రూపొందించాము.
అప్పుడు, మేము ప్రధాన పద్ధతిలో CUnit రన్నర్ కోడ్‌ని కలిగి ఉన్నాము. ఇక్కడ, మేము “CU_pSuite” పద్ధతి నుండి “pSuite1” మరియు “pSuite2” అనే రెండు సూట్‌లను సృష్టించాము మరియు ఈ సూట్‌లకు NULL విలువను కేటాయించాము. టెస్ట్ రిజిస్ట్రీలో నమోదు చేయవలసిన CUnit పరీక్షను అమలు చేయడానికి మేము ఈ సూట్‌లను సృష్టించాము. “test_registry”కి సూట్‌లను జోడించే ముందు, మేము రిజిస్ట్రీని సృష్టించాము మరియు దానిని “if condition”తో ప్రారంభించాము. మేము పరీక్ష సూట్‌ల కోసం రిజిస్ట్రీని రూపొందించడానికి “CU_initialze_registry()” పద్ధతిని ఉపయోగించాము.
ఆ తర్వాత, మేము CUnit యొక్క “CU_add_suite” పద్ధతిని ప్రారంభించడం ద్వారా పరీక్ష రిజిస్ట్రీకి pSuite1ని జోడించాము. ఆ తర్వాత, “CU_add_test()” పద్ధతిని ఉపయోగించడం ద్వారా మేము మా పరీక్షలను, “test_MySum” మరియు “test_MyDiff”ని పేర్కొన్న సూట్‌లకు జోడించాము. చివరికి, మేము “CU_basic_run_tests()” పద్ధతికి కాల్ చేయడం ద్వారా CUnit పరీక్ష ఫలితాలను ప్రదర్శించాము మరియు ఫలితాలు విజయవంతంగా ప్రదర్శించబడిన తర్వాత రిజిస్ట్రీని శుభ్రం చేసాము. CUnit పరీక్షలు చేస్తున్నప్పుడు ఎదురైన లోపం “CU_get_error()” ఫంక్షన్ ద్వారా త్రోసివేయబడుతుంది.
మునుపటి CUnit పరీక్ష ఫైల్ mytest.c ఫైల్‌గా సేవ్ చేయబడింది. మేము ఈ C ఫైల్‌ను GCC కమాండ్‌తో అమలు చేసాము. మేము CUnit టెస్ట్ ఫైల్ ఎగ్జిక్యూషన్ కోసం -lcunit ఫ్లాగ్‌ని ఉపయోగించాము. ఈ ఆదేశంతో, మా కోడ్ కంపైల్ చేయబడింది. అప్పుడు, మేము mytest ఫైల్‌ను అమలు చేసాము మరియు అన్ని పరీక్షలు ఎటువంటి వైఫల్యం లేకుండా ఉత్తీర్ణత సాధించడంతో CUnit పరీక్ష యొక్క ఆశించిన ఫలితాలను ఇది చూపింది.
ఉదాహరణ 2
CUnit విధానం ద్వారా మేము 'fread' మరియు 'fprintf' అనే రెండు ఫైల్ హ్యాండ్లింగ్ పద్ధతులను పరీక్షించిన మరొక ఉదాహరణ మాకు ఉంది. మేము CUnit పరీక్ష ఫంక్షన్‌లను ఉపయోగించి తాత్కాలిక ఫైల్‌ని తెరిచి మూసివేసాము. CUnit పరీక్ష కార్యకలాపాలు తాత్కాలిక ఫైల్ నుండి వ్రాయడం మరియు చదవడం ద్వారా లైబ్రరీ ఫంక్షన్‌లను పరీక్షిస్తాయి.
##include
#
#include
#'CUnit/Basic.h'ని చేర్చండి
స్టాటిక్ ఫైల్ * ఫైల్ = NULL;
int init_suite1 ( శూన్యం )
{
ఉంటే ( NULL == ( ఫైల్ = ఫోపెన్ ( 'MyFile.txt' , 'w +' ) ) ) {
తిరిగి -1 ;
}
లేకపోతే {
తిరిగి 0 ;
}
}
int clean_suite1 ( శూన్యం )
{
ఉంటే ( 0 ! = దగ్గరగా ( ఫైల్ ) ) {
తిరిగి -1 ;
}
లేకపోతే {
ఫైల్ = NULL;
తిరిగి 0 ;
}
}
పరీక్ష_fprintf శూన్యం ( శూన్యం )
{
int x1 = 10 ;
ఉంటే ( శూన్య ! = ఫైల్ ) {
WITH_ASSERT ( రెండు == fprintf ( ఫైల్ , 'ప్ర \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( ఫైల్ , 'x1 = %d' , x1 ) ) ;
}
}
పరీక్ష_ఫ్రెడ్ శూన్యం ( శూన్యం )
{
సంతకం చేయని చార్ బఫర్ [ ఇరవై ] ;
ఉంటే ( శూన్య ! = ఫైల్ ) {
రివైండ్ ( ఫైల్ ) ;
WITH_ASSERT ( 9 == fread ( బఫర్, పరిమాణం ( సంతకం చేయని చార్ ) , ఇరవై , ఫైల్ ) ) ;
WITH_ASSERT ( 0 == strncmp ( బఫర్, 'ప్ర \n x1 = 10' , 9 ) ) ;
}
}
పూర్ణాంక ప్రధాన ( )
{
CU_pSuite pSuite = NULL;
ఉంటే ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
తిరిగి CU_get_error ( ) ;
pSuite = CU_add_suite ( 'సూట్1' , init_suite1, clean_suite1 ) ;
ఉంటే ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
ఉంటే ( ( NULL == CU_add_test ( pSuite, 'fprintf() ఫంక్షన్ టెస్ట్' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'ఫ్రెడ్() ఫంక్షన్ టెస్ట్' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
తిరిగి CU_get_error ( ) ;
}
హెడర్ ఫైల్‌లో, మేము CUnit ప్రామాణిక లైబ్రరీ “CUnit.h/Basic.h”ని నిర్వచించాము. అప్పుడు, మేము పరీక్షల ద్వారా ఉపయోగించే ఫైల్‌కు పాయింటర్‌గా “ఫైల్”ని ప్రకటించాము. తరువాత, మేము 'init_suite1' ఫంక్షన్‌ను రూపొందించాము, అది తాత్కాలిక ఫైల్ 'MyFile.txt'ని తెరుస్తుంది మరియు విజయంపై సున్నా విలువను అందిస్తుంది; లేకుంటే, సున్నా కాని విలువ తిరిగి ఇవ్వబడుతుంది. ఫైల్‌ను మూసివేయడానికి, మేము సూట్ క్లీనప్ ఫంక్షన్‌ను సృష్టించాము, ఇది తాత్కాలిక ఫైల్‌ను మూసివేసేటప్పుడు వైఫల్యంపై సున్నా కాని విలువను కూడా అందిస్తుంది. లేకపోతే, తాత్కాలిక ఫైల్‌ను విజయవంతంగా మూసివేస్తే, సున్నా విలువ పొందబడుతుంది. అప్పుడు, మేము 'test_fprintf' ఫంక్షన్‌ను అమలు చేసాము, ఇక్కడ మేము డేటాను తాత్కాలిక ఫైల్ 'MYfile.txt'లో చొప్పించాము. ఈ టెస్ట్ ఫంక్షన్‌లు మేము ఫైల్‌లో వ్రాయడానికి ప్రయత్నించిన బైట్‌ల సంఖ్యను కూడా ధృవీకరించాయి.
ఆ తర్వాత, మేము fread పద్ధతిని పరీక్షించడానికి 'test_fread' ఫంక్షన్ కోసం మరొక ఫంక్షన్‌ని సృష్టించాము. ఇక్కడ, 'test_fprinf()' ఫంక్షన్ ద్వారా గతంలో వ్రాసిన డేటాలో పేర్కొన్న అక్షరాలు ఉన్నాయని మేము తనిఖీ చేసాము. అప్పుడు, సెటప్ చేయబడిన మరియు అమలు చేయబడిన పరీక్షలు నిర్వహించబడే ప్రధాన విధిని మేము కలిగి ఉన్నాము. మేము ప్రధాన ఫంక్షన్‌లో “pSuite”ని నిర్వచించాము మరియు “CU_initialize_resgistry” పరీక్ష ఫంక్షన్‌ని ఉపయోగించి రిజిస్ట్రీని ప్రారంభించాము. మేము సూట్‌ను రిజిస్ట్రీకి జోడించడానికి “CU_add_suite” ఫంక్షన్‌ని కూడా పిలిచాము మరియు “CU_add_test” ఫంక్షన్ సహాయంతో సూట్‌లకు పేర్కొన్న పరీక్షలను జోడించాము.
కోడ్ యొక్క ఫలితాలను ప్రదర్శించడానికి ప్రాథమిక CUnit పరీక్ష ఇంటర్‌ఫేస్‌లు చివరికి ఉపయోగించబడతాయి. ప్రధాన ఫంక్షన్ విజయవంతంగా అమలు చేయబడినప్పుడు 'CUE_SUCCESS'ని మరియు విజయవంతం కాని అమలులో వేరే 'CUnit_error' కోడ్‌ని అందిస్తుంది.
మేము CUnit పరీక్ష కోసం మునుపటి కోడ్‌ను అమలు చేసాము, ఇది ప్రోగ్రామ్ సారాంశం మరియు విజయవంతమైన పరీక్షల పద్ధతి సందేశాన్ని ప్రదర్శిస్తుంది.
ముగింపు
CUnit అనేది వివిధ వినియోగదారు ఇంటర్‌ఫేస్‌లను అందించే కోర్ ఫ్రేమ్‌వర్క్. ఇది టెస్ట్ సూట్‌లు, టెస్ట్ కేసులు మరియు టెస్ట్ రిజిస్ట్రీలను నిర్వహించడానికి మమ్మల్ని అనుమతిస్తుంది. ప్రోగ్రామ్‌లను పరీక్షించడం మరియు ఆ పరీక్షల ఫలితాలను చూడడం వినియోగదారు ఇంటర్‌ఫేస్‌ల ద్వారా సులభతరం చేయబడుతుంది. మేము ఈ కథనంతో C లో CUnit పరీక్ష ఫ్రేమ్‌వర్క్‌ను కవర్ చేసాము. మేము ఇన్‌స్టాలేషన్‌ను ప్రదర్శించాము మరియు C భాషలో రెండు రన్నింగ్ ప్రోగ్రామ్‌లను అమలు చేసాము. పరీక్షించిన మునుపటి ప్రోగ్రామ్‌లు విజయవంతమైన ఫలితాలను ఇచ్చాయి.