CUnit அமைப்பு C இல் யூனிட் சோதனையைச் செய்யப் பயன்படுகிறது, இது சோதனைகளை நிர்வாகம் செய்வதற்கும் செயல்படுத்துவதற்கும் உதவுகிறது. இது பொதுவாகப் பயன்படுத்தப்படும் தரவு வகைகளைச் சோதிப்பதற்கான பலவிதமான வலியுறுத்தல்களை உள்ளடக்கியது மற்றும் சோதனைக் கட்டமைப்புகளை உருவாக்க எளிய கட்டமைப்பைப் பயன்படுத்துகிறது. பயனரின் சோதனைக் குறியீடு CUnit உடன் இணைக்கப்பட்டுள்ளது, இது நிலையான நூலகமாக வடிவமைக்கப்பட்டுள்ளது. CUnit சோதனை கட்டமைப்பைப் பயன்படுத்தி C நிரலின் பணிகள் மற்றும் செயல்பாடுகளின் செயல்திறனை நாம் ஆராயலாம். சி நிரலின் ஒவ்வொரு குறிப்பிட்ட பணியும் வெவ்வேறு உள்ளீட்டு சூழ்நிலைகள் மற்றும் வெளியீட்டு வரம்புகளைக் கொண்டுள்ளது. C நிரலைச் சோதிக்க CUnit ஐப் பயன்படுத்த, முதலில் அதை நம் கணினியில் நிறுவ வேண்டும். CUnit ஐ நிறுவுவதற்கான படிகள் கீழே கொடுக்கப்பட்டுள்ளன.
உபுண்டு 22.04 இல் CUnit கட்டமைப்பை எவ்வாறு பயன்படுத்துவது
எங்கள் கணினியில் CUnit சோதனை கட்டமைப்பைப் பயன்படுத்த, நாம் நிறுவல் படிகளைப் பின்பற்ற வேண்டும். இந்த படிகள் உபுண்டு 22.04 அமைப்புக்கு பொருந்தும். நிறுவுவதற்கு முன், நாங்கள் முதலில் எங்கள் கணினியைப் புதுப்பித்தோம். apt கட்டளையுடன் புதுப்பிக்க கணினிக்கு sudo சிறப்புரிமை தேவை.
சூடோ சலுகைகளைப் பெற, டெர்மினல் சூடோ பயனரிடமிருந்து அங்கீகாரத்தைக் கேட்டது. பின்னர், கீழே காட்டப்பட்டுள்ளபடி, கணினி தொகுப்புகளையும் அவற்றின் சார்புகளையும் புதுப்பிக்கவும்.
இப்போது, பின்வரும் கட்டளையைப் பயன்படுத்தி CUnit கட்டமைப்பை நிறுவியுள்ளோம். இந்த கட்டளை libcunitl, libcunitl-doc மற்றும் libcunitl-dev தொகுப்புகளை தொகுப்பு களஞ்சியத்திலிருந்து நிறுவ முடியும்.
CUnit நிறுவல் கட்டளையை இயக்கியதும், பயனர் கடவுச்சொல் தேவை. CUnit இன்றியமையாத தொகுப்புகள் எங்கள் Ubuntu 22.04 இல் நிறுவப்பட்டுள்ளன.
எடுத்துக்காட்டு 1
முந்தைய பிரிவில் CUnit கட்டமைப்பின் நிறுவல் படியை முடித்தோம். இப்போது, CUnit சோதனை கட்டமைப்பைப் பயன்படுத்தி, பின்வரும் எடுத்துக்காட்டில் எதிர்பார்க்கப்படும் முடிவுகளைக் காண, தொகை மற்றும் வேறுபாடு முறையைச் சோதித்துள்ளோம்.
#
#
#
#
#'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;
}
void test_MySum ( வெற்றிடமானது )
{
WITH_ASSERT ( 4 ==MySum ( இரண்டு , இரண்டு ) ) ;
WITH_ASSERT ( 8 ==MySum ( 5 , 3 ) ) ;
WITH_ASSERT ( இரண்டு ==MySum ( - இரண்டு , 4 ) ) ;
WITH_ASSERT ( 7 ==MySum ( 0 , 7 ) ) ;
}
void test_MyDiff ( வெற்றிடமானது )
{
WITH_ASSERT ( 3 ==மைடிஃப் ( 5 , இரண்டு ) ) ;
WITH_ASSERT ( - 4 ==மைடிஃப் ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==மைடிஃப் ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==மைடிஃப் ( 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_அடிப்படை_ரன்_சோதனைகள் ( ) ;
CU_cleanup_registry ( ) ;
திரும்ப CU_get_error ( ) ;
}
முதலில், CUnit கட்டமைப்பை உருவாக்க, 'CUnit/Basic.h' என்ற CUnit நூலகத்தை உள்ளடக்கிய முக்கிய சொல்லுடன் செருகியுள்ளோம். இந்த சி நூலகம் யூனிட் டெஸ்டிங் ஃப்ரேம்வொர்க்குகளுக்கானது மற்றும் எளிமையான கன்சோல் வெளியீட்டு இடைமுகத்தை வழங்குகிறது. அதன் பிறகு இரண்டு செயல்பாடுகளைச் சேர்த்துள்ளோம், '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 சோதனைச் செயல்பாடுகள் நூலகச் செயல்பாடுகளை தற்காலிகக் கோப்பிலிருந்து எழுதுதல் மற்றும் படிப்பதன் மூலம் சோதிக்கின்றன.
##
#
#
#'CUnit/Basic.h' அடங்கும்
நிலையான கோப்பு * கோப்பு = NULL;
int init_suite1 ( வெற்றிடமானது )
{
என்றால் ( NULL == ( கோப்பு = fopen ( 'MyFile.txt' , 'w +' ) ) ) {
திரும்ப -1 ;
}
வேறு {
திரும்ப 0 ;
}
}
int clean_suite1 ( வெற்றிடமானது )
{
என்றால் ( 0 ! = fclose ( கோப்பு ) ) {
திரும்ப -1 ;
}
வேறு {
கோப்பு = NULL;
திரும்ப 0 ;
}
}
void test_fprintf ( வெற்றிடமானது )
{
int x1 = 10 ;
என்றால் ( ஏதுமில்லை ! = கோப்பு ) {
WITH_ASSERT ( இரண்டு == fprintf ( கோப்பு , 'கே \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( கோப்பு , 'x1 = %d' , x1 ) ) ;
}
}
void test_fread ( வெற்றிடமானது )
{
கையொப்பமிடப்படாத சார் தாங்கல் [ இருபது ] ;
என்றால் ( ஏதுமில்லை ! = கோப்பு ) {
முன்னாடி ( கோப்பு ) ;
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, 'fread() செயல்பாடு சோதனை' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
திரும்ப CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_அடிப்படை_ரன்_சோதனைகள் ( ) ;
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 மொழியில் செயல்படுத்தினோம். முந்தைய சோதனை திட்டங்கள் வெற்றிகரமான முடிவுகளை அளித்தன.