מערכת CUnit משמשת לביצוע בדיקת היחידה ב-C המאפשרת ניהול וביצוע של הבדיקות. הוא מכסה מגוון רחב של קביעות לבדיקת סוגי נתונים נפוצים ומשתמש בארכיטקטורה פשוטה ליצירת מבני בדיקה. קוד הבדיקה של המשתמש מקושר ל-CUnit, שעוצב כספרייה סטטית. אנו עשויים לבחון את ביצועי המשימות והפונקציות של תוכנית C באמצעות מסגרת הבדיקה של CUnit. לכל משימה מסוימת של תוכנית C יש נסיבות קלט ומגבלות פלט שונות. כדי להשתמש ב-CUnit לבדיקת תוכנית C, עלינו להתקין אותה תחילה במערכת שלנו. השלבים להתקנת CUnit מפורטים להלן.
כיצד להשתמש במסגרת CUnit באובונטו 22.04
כדי להשתמש במסגרת הבדיקה של CUnit במערכת שלנו, עלינו לבצע את שלבי ההתקנה. שלבים אלה חלים על מערכת אובונטו 22.04. לפני ההתקנה, עדכנו תחילה את המערכת שלנו. המערכת דרשה הרשאות sudo כדי להתעדכן בפקודה apt.
כדי לרכוש הרשאות sudo, המסוף ביקש את האימות ממשתמש sudo. לאחר מכן, עדכן את חבילות המערכת ואת התלות שלהן, כפי שמוצג להלן.
כעת, התקנו את מסגרת CUnit באמצעות הפקודה הבאה. פקודה זו יכולה להתקין את החבילות libcunitl, libcunitl-doc ו-libcunitl-dev ממאגר החבילות.
לאחר ביצוע פקודת ההתקנה של CUnit, סיסמת המשתמש נדרשת. החבילות החיוניות של CUnit הותקנו באובונטו 22.04 שלנו.
דוגמה 1
השלמנו את שלב ההתקנה של מסגרת CUnit בסעיף הקודם. כעת, בדקנו את שיטת הסכום וההפרש כדי לראות את התוצאות הצפויות בדוגמה הבאה באמצעות מסגרת הבדיקה CUnit.
#include
#include
#include
#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;
}
void test_MySum ( בָּטֵל )
{
WITH_ASSERT ( 4 ==הסכום שלי ( שתיים , שתיים ) ) ;
WITH_ASSERT ( 8 ==הסכום שלי ( 5 , 3 ) ) ;
WITH_ASSERT ( שתיים ==הסכום שלי ( - שתיים , 4 ) ) ;
WITH_ASSERT ( 7 ==הסכום שלי ( 0 , 7 ) ) ;
}
void 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 ) ) ;
}
int main ( בָּטֵל )
{
CU_pSuite pSuite1,pSuite2 = NULL;
אם ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
לַחֲזוֹר CU_get_error ( ) ;
pSuite1 = CU_add_suite ( 'Test Suite1' , 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' לאתחול של פונקציית ה-suite ו-'clean_suite' לניקוי פונקציית ה-suite, לתוכנית שלנו לבדיקה.
לאחר מכן, בנינו שיטות, 'MySum' ו-'MyDiff', שייבחנו על ידי ה-CUnit. קראנו לבנאי עבור פונקציות אלו, המחזיק את המשתנים שעליהם בוצעו פעולות סכום והפרש. לאחר מכן, הקמנו פונקציה בתור 'test_MySum' לבדיקה. בתוך הפונקציה, השתמשנו בשיטת 'CU_ASSERT', שבה מוקצים ביטויי ה-init עבור הסכום. זהה ל-'test_MySum', בנינו את הפונקציה test_MyDiff כדי לבדוק את הביטוי עבור פעולות שונות באמצעות שיטת 'CU_ASSERT'.
לאחר מכן, יש לנו את קוד הרץ של CUnit בתוך השיטה הראשית. כאן, יצרנו שתי חבילות, 'pSuite1' ו-'pSuite2', משיטת 'CU_pSuite' והקצינו לחבילות הללו ערך NULL. יצרנו חבילות אלה כדי לבצע את בדיקת CUnit שאמורה להירשם ברישום הבדיקות. לפני הוספת הסוויטות ל- 'test_registry', יצרנו את הרישום ואתחול אותו ב-'if condition'. השתמשנו בשיטת 'CU_initialze_registry()' ליצירת הרישום עבור חבילות בדיקה.
לאחר מכן, הוספנו את ה-pSuite1 לרישום הבדיקה על ידי הפעלת שיטת 'CU_add_suite' של CUnit. לאחר מכן, הוספנו את הבדיקות שלנו, 'test_MySum' ו-'test_MyDiff', לסוויטות שצוינו על ידי שימוש בשיטת 'CU_add_test()'. בסופו של דבר, הצגנו את התוצאות של בדיקת CUnit על ידי קריאה לשיטת 'CU_basic_run_tests()' וניקינו את הרישום לאחר שהתוצאות הוצגו בהצלחה. השגיאה שנתקלה בעת ביצוע בדיקות CUnit תושפך על ידי הפונקציה 'CU_get_error()'.
קובץ הבדיקה הקודם של CUnit נשמר כקובץ mytest.c. ביצענו קובץ C זה עם הפקודה GCC. השתמשנו בדגל -lcunit לביצוע קובץ בדיקה של CUnit. עם פקודה זו, הקוד שלנו מורכב. לאחר מכן, ביצענו את קובץ ה-mytest, והוא הראה את התוצאות הצפויות של מבחן CUnit שכן כל הבדיקות עברו ללא כל כישלון.
דוגמה 2
יש לנו דוגמה נוספת שבה בדקנו את שתי שיטות הטיפול בקבצים, 'fread' ו-'fprintf', על ידי גישת CUnit. פתחנו וסגרנו את הקובץ הזמני באמצעות פונקציות הבדיקה של CUnit. פעולות הבדיקה של CUnit בודקות את פונקציות הספרייה על ידי כתיבה וקריאה מהקובץ הזמני.
#include#include
#include
#include
#include 'CUnit/Basic.h'
סטטי FILE * קוֹבֶץ = NULL;
int init_suite1 ( בָּטֵל )
{
אם ( NULL == ( קוֹבֶץ = פופן ( '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 ( בָּטֵל )
{
מאגר char unsigned [ עשרים ] ;
אם ( ריק ! = קוֹבֶץ ) {
להריץ לאחור ( קוֹבֶץ ) ;
WITH_ASSERT ( 9 == פחד ( חיץ, גודלו ( char לא חתום ) , עשרים , קוֹבֶץ ) ) ;
WITH_ASSERT ( 0 == strncmp ( בַּלָם, 'ש \n x1 = 10 אינץ' , 9 ) ) ;
}
}
int main ( )
{
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_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
לַחֲזוֹר CU_get_error ( ) ;
}
בתוך קובץ הכותרת, הגדרנו את הספרייה הסטנדרטית של CUnit 'CUnit.h/Basic.h'. לאחר מכן, הכרזנו על 'קובץ' כמצביע לקובץ המשמש את הבדיקות. לאחר מכן, בנינו את הפונקציה 'init_suite1' שפותחת את הקובץ הזמני 'MyFile.txt' ומחזירה את הערך אפס עם הצלחה; אחרת, ערך שאינו אפס יוחזר. כדי לסגור את הקובץ, יצרנו את פונקציית ניקוי הסוויטות, שגם מחזירה ערך שאינו אפס בעת כשל בזמן סגירת הקובץ הזמני. אחרת, בסגירה מוצלחת של הקובץ הזמני, מתקבל ערך אפס. לאחר מכן, פשוט יישמנו פונקציה 'test_fprintf' שבה הכנסנו את הנתונים לקובץ הזמני 'MYfile.txt'. פונקציות הבדיקה הללו גם אימתו את מספר הבתים שניסינו לכתוב בקובץ.
לאחר מכן, יצרנו פונקציה נוספת עבור הפונקציה 'test_fread' כדי לבדוק את שיטת fread. כאן, בדקנו שהתווים שצוינו נמצאים בנתונים שנכתבו קודם לכן על ידי הפונקציה 'test_fprinf()'. לאחר מכן, יש לנו את הפונקציה העיקרית שבה הבדיקות שהוגדרו ובוצעו מטופלות. הגדרנו את ה-'pSuite' בפונקציה הראשית ואתחלנו את הרישום באמצעות פונקציית הבדיקה 'CU_initialize_resgistry'. קראנו גם לפונקציה 'CU_add_suite' כדי להוסיף את החבילה לרישום והוספנו את הבדיקות שצוינו לחבילות בעזרת הפונקציה 'CU_add_test'.
ממשקי הבדיקה הבסיסיים של CUnit משמשים בסופו של דבר להצגת תוצאות הקוד. שימו לב שהפונקציה הראשית מחזירה 'CUE_SUCCESS' לאחר ביצוע מוצלח וקוד 'CUnit_error' אחר בביצוע לא מוצלח.
הרצנו את הקוד הקודם למבחן CUnit, שהציג את סיכום התוכנית והודעת שיטת הבדיקות המוצלחות.
סיכום
CUnit היא מסגרת ליבה המספקת ממשקי משתמש שונים. זה מאפשר לנו לנהל חבילות בדיקה, מקרי בדיקה ורישום בדיקות. בדיקת התוכנות וראיית התוצאות של הבדיקות הללו מקל על ידי ממשקי המשתמש. כיסינו את מסגרת הבדיקה של CUnit ב-C במאמר זה. הדגמנו את ההתקנה ולאחר מכן הטמענו שתי תוכניות פועלות בשפת C. התוכניות הקודמות שנבדקו הניבו תוצאות מוצלחות.