למד כיצד להשתמש בהצהרות במבחני JUnit שלך

ה-JUnit Assertions Class מכיל אוסף של שיטות סטטיות המאפשרות לך לבצע בדיקות יחידה. קביעות הן אחת מתכונות הליבה של JUnit. לכיתה זו יש למעלה מחמישים שיטות מגוונות. מבחני מחלקה מסוימים של Assertions ייכשלו אם תנאי הוא אמיתי, בעוד שאחרים ייכשלו אם תנאי הוא שקר.

למחלקה Assertions יש גם הרבה שיטות עמוסות מדי. לכל שיטת קביעה יש לפחות שתי שיטות עמוסות מדי. גלה כמה מהשיטות הפופולריות יותר של מחלקות Assertions וגלה כיצד להשתמש בהן לביצוע בדיקות יחידה.

שיטת assertEquals

לשיטת JUnit 5 assertEquals יש למעלה מעשר וריאציות. שיטה זו היא אחת השיטות הפופולריות יותר בכיתה Assertions. וריאציה אחת של שיטת assertEquals לוקחת ערך צפוי ואת הפונקציה שברצונך להעריך (ערך בפועל). גרסה עיקרית שניה לוקחת טיעון שלישי נוסף. זוהי הודעת שגיאה שתוצג אם בדיקת יחידת JUnit נכשל.

עומס יתר של שיטת assertEquals מתרחש עם סוגי נתונים שונים. חלק משיטות עומס יתר של assertEquals לוקחות ארגומנט רביעי שנקרא delta. גרסאות אחרות מחליפות את מחרוזת הכשל בממשק פונקציונלי של ספק, בצורה של a ביטוי למבדה.

AssertionsMethods Class Java

חֲבִילָה com.program;
פּוּמְבֵּימעמדשיטות קביעות{
פּוּמְבֵּיסטָטִיintכיכר(int מספר){
לַחֲזוֹר num * num;
 }
}

למחלקה של AssertionsMethods Java למעלה יש שיטה אחת שנקראת square. שיטת הריבוע לוקחת ערך שלם ומחזירה את הריבוע שלו. כדי לבדוק את שיטת המרובע וכל שיטה עתידית מהמחלקה AssertionsMethods תצטרך ליצור מקרה מבחן JUnit.

מקרה הבדיקה של AssertionsMethodsTest JUnit

חֲבִילָה com.program;
יְבוּאסטָטִיorg.junit.לִטעוֹן.assertEquals;
יְבוּאסטָטִיorg.junit.צדק.api.הצהרות.*;
יְבוּאorg.junit.צדק.api.מִבְחָן;
מעמדבדיקות שיטות{
@מִבְחָן
בָּטֵלtestSquare(){
assertEquals(25, שיטות טענה.כיכר(5));
 assertEquals (36, AssertionMethods.square (6), "ערכי הריבוע שלך לא התאימו.");
 assertEquals (49, AssertionMethods.square (7), () ->"ערכי הריבוע שלך לא התאימו.");
 }
}

שיטת testSquare() משתמשת בשלוש וריאציות של assertEquals() כדי לבדוק את שיטת square(). כל assertEquals() הוא הצלחה, מכיוון שכל הערכים הצפויים תואמים לערכים המוחזרים בפועל בשיטת square() .

שיטת assertNull

למחלקה JUnit Assertions יש בדיוק שלוש שיטות assertNull. כל אחת מהשיטות הללו לוקחת ארגומנט אחד או יותר וטוען אם האובייקט הנתון הוא null. אם אובייקט נתון אינו ריק, הבדיקה תיכשל.

@מִבְחָן
פּוּמְבֵּיבָּטֵלtestStringValue(){
חוּט stringValue = ריק;
 assertNull (stringValue);
 assertNull (stringValue, "ערך המחרוזת שלך אינו ריק");
 assertNull (stringValue, () ->"ערך המחרוזת שלך אינו ריק");
}

השיטה הראשונה assertNull() לוקחת אובייקט מחרוזת ובודקת אם הוא null. השיטה השנייה assertNull() לוקחת אובייקט מחרוזת והודעת מחרוזת כדי להציג אם הבדיקה נכשלת. השיטה השלישית והאחרונה assertNull() לוקחת את האובייקט שברצונך להעריך וממשק פונקציונלי של ספק.

במקרה המבחן לעיל, ממשק הספק משמש כיעד הקצאה לביטוי למבדה. ביטוי הלמבדה יוצר הודעת שגיאה אם ​​הבדיקה נכשלת.

שיטת assertTrue

לשיטת assertTrue() יש שש וריאציות. כל שיטה קובעת אם תנאי נתון נכון. אם תנאי assertTrue() הוא שקר, הבדיקה תיכשל.

@מִבְחָן
בָּטֵלtestEvenNumbers(){
int מספר1 = 10;
int מספר 2 = 16;
int מספר 3 = 26;
 assertTrue (num1 < num2);
 assertTrue (מספר 3 > מספר 2, "המצב שלך לא נכון.");
 assertTrue (num1 < מספר 3, () ->" המצב שלך לא נכון."); 
 assertTrue(() -> num1%2 == 0);
 assertTrue(() -> num2%2 == 0, "הערך שלך אינו מספר זוגי.");
 assertTrue(() -> num3%2 == 0, () ->"הערך שלך אינו מספר זוגי.");
}

השיטה testEvenNumbers() מדגימה כיצד להשתמש בכל שש שיטות assertTrue(). כל השיטות לעיל נכונות, לכן, מבחן יחידה זה מתבצע ללא כשל או שגיאה.

• assertTrue (תנאי בוליאני): שיטה זו לוקחת תנאי בוליאני וטוען אם הוא נכון. הדוגמה של שיטה זו בקוד שלמעלה קובעת אם הערך השלם הראשון קטן מהשני.
• assertTrue (מצב בוליאני, הודעת מחרוזת): שיטה זו לוקחת תנאי בוליאני כדי לבדוק ומחרוזת להציג אם היא שקר.
• assertTrue (מצב בוליאני, ספק messageSupplier): שיטה זו לוקחת ממשק פונקציונלי בוליאני וספק, כביטוי למבדה. ספק ההודעה מכיל מחרוזת להצגה אם התנאי הבולאני הוא שקרי.
• assertTrue (BooleanSupplier booleanSupplier): שיטה זו לוקחת ממשק פונקציונלי של BooleanSupplier, בצורה של ביטוי למבדה המוערך כ-true או false. הדוגמה של שיטה זו בקוד משתמשת בביטוי למבדה. הוא בודק את שאר המספר השלם הראשון חלקי שניים כדי לקבוע אם הוא זוגי או אי-זוגי.
• assertTrue (BooleanSupplier booleanSupplier, הודעה מחרוזת): שיטה זו לוקחת ממשק פונקציונלי של BooleanSupplier בצורה של ביטוי למבדה. נדרשת גם הודעת מחרוזת כדי להדפיס אם BooleanSupier אינו נכון.
• assertTrue (BooleanSupplier booleanSupplier, ספק messageSupplier): שיטה זו דורשת ממשק פונקציונלי BooleanSupplier כדי לקבוע. זה גם דורש ממשק פונקציונלי של ספק, שהוא ביטוי למבדה שידפיס ערך מחרוזת אם הבדיקה תיכשל.

שיטת assertFalse

שיטת assertFalse() היא ההפך משיטת assertTrue(). שיטה זו מעריכה מצב נתון כדי לראות אם הוא שקרי. אם תנאי נתון נכון, אזי מבחן assertFalse() ייכשל. לשיטת assertFalse() יש גם שש וריאציות שמקבלות את אותם ארגומנטים כמו עמיתיהם assertTrue() שלהם.

@מִבְחָן
בָּטֵלtestNotEvenNumbers(){
int מספר1 = 11;
int מספר 2 = 17;
int מספר 3 = 27;
 assertFalse (מספר2 < num1);
 assertFalse (מספר2 > מספר 3, " מצבך אינו שקרי.");
 assertFalse (מספר3 < מספר1, () ->" מצבך אינו שקרי.");
 assertFalse(() -> num1%2 == 0);
 assertFalse(() -> num2%2 == 0, "הערך שלך הוא מספר זוגי.");
 assertFalse(() -> num3%2 == 0, () ->"הערך שלך הוא מספר זוגי.");
}

שש שיטות assertFalse() בשיטת testNotEvenNumbers() מביאות כולן ל-false, כלומר בדיקות assertFalse() מוצלחות.

היתרונות של בדיקת יחידות

בדיקת יחידות היא חלק בלתי נפרד מתהליך פיתוח התוכנה. פרויקטי תוכנה גדולים נכשלים מסיבות שונות, החל מהצוותים שעובדים עליהם ועד לגישות פיתוח.

מטרת בדיקת יחידות היא למנוע כשל בתוכנה על ידי מתן זיהוי שגיאות מוקדם. זה דורש מהצוותים לפתח מפרטים ברורים, לשפר את עיצוב התוכנה באמצעות תיעוד שגיאות ולספק תמיכה לתחזוקת תוכנה.

בדיקת יחידות היא לא גישת בדיקת התוכנה היחידה שאתה צריך להשתמש במחזור חיי הפיתוח שלך, זה פשוט מקום טוב מאוד להתחיל בו.