קביעות ב- JUnit 4 ו- JUnit 5

1. הקדמה

במאמר זה, אנו נבחן בפירוט את הקבוצות הזמינות ב- JUnit.

בעקבות המעבר מ- JUnit 4 ל- JUnit 5 ומדריך למאמרי JUnit 5, אנו נכנסים כעת לפרטים אודות ההצהרות השונות הקיימות ב- JUnit 4 ו- JUnit 5.

נדגיש גם את השיפורים שבוצעו בהצהרות עם JUnit 5.

2. קביעות

קביעות הן שיטות שימוש לתמיכה בקביעת תנאים במבחנים; שיטות אלה נגישות דרך לִטעוֹן בכיתה, ביחידה 4, וב- קביעות האחד, ביוני 5.

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

נתחיל לבחון את ההצהרות הקיימות ב- JUnit 4.

3. קביעות ב- JUnit 4

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

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

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

נתחיל עם ה- assertEquals אחד.

3.1. assertEquals

ה assertEquals קביעה מאמתת שהערכים הצפויים והערכים בפועל שווים:

@ מבחן ציבורי בטל כאשר AssertingEquality_thenEqual () {מחרוזת צפויה = "Baeldung"; מחרוזת בפועל = "Baeldung"; assertEquals (צפוי, ממשי); }

ניתן גם לציין הודעה שתוצג כאשר הקביעה נכשלת:

assertEquals ("כישלון - מחרוזות אינן שוות", צפוי, ממשי);

3.2. assertArrayEquals

אם אנו רוצים לקבוע ששני מערכים הם שווים, נוכל להשתמש ב- assertArrayEquals:

@ מבחן ציבורי בטל כאשר AssertingArraysEquality_thenEqual () {char [] expect = {'J', 'u', 'n', 'i', 't'}; char [] actual = "Junit" .toCharArray (); assertArrayEquals (צפוי, ממשי); }

אם שני המערכים הם ריק, הקביעה תראה אותם שווים:

@Test הציבור בטל givenNullArrays_whenAssertingArraysEquality_thenEqual () {int [] צפוי = null; int [] בפועל = null; assertArrayEquals (צפוי, ממשי); }

3.3. לטעון NotNull ו לטעון אפס

כשאנחנו רוצים לבדוק אם אובייקט הוא ריק אנחנו יכולים להשתמש ב- לטעון אפס טַעֲנָה:

@Test הציבור בטל כאשרAssertingNull_thenTrue () {מכונית אובייקט = null; assertNull ("המכונית צריכה להיות אפס", מכונית); }

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

3.4. assertNotSame ו assertSame

עם assertNotSame, ניתן לאמת אם שני משתנים אינם מתייחסים לאותו אובייקט:

@ מבחן ציבורי בטל כאשר AssertingNotSameObject_thenDifferent () {Object cat = Object חדש (); כלב אובייקט = אובייקט חדש (); assertNotSame (חתול, כלב); }

אחרת, כאשר אנו רוצים לוודא ששני משתנים מתייחסים לאותו אובייקט, אנו יכולים להשתמש ב- assertSame טַעֲנָה.

3.5. לטעון נכון ו לטעון שקר

במקרה שאנחנו רוצים לוודא שמצב מסוים הוא נָכוֹן אוֹ שֶׁקֶר, אנו יכולים בהתאמה להשתמש ב- לטעון נכון קביעה או לטעון שקר אחד:

@Test הציבור בטל כאשרAssertingConditions_thenVerified () {assertTrue ("5 גדול יותר מ- 4", 5> 4); assertFalse ("5 אינו גדול מ- 6", 5> 6); }

3.6. לְהִכָּשֵׁל

ה לְהִכָּשֵׁל קביעה נכשלת במבחן שזורק AssertionFailedError. ניתן להשתמש בו כדי לוודא שנזרק חריג בפועל או כאשר אנו רוצים לבצע בדיקה נכשלת במהלך הפיתוח שלה.

בואו נראה איך נוכל להשתמש בו בתרחיש הראשון:

@Test ציבורי בטל כאשרCheckingExceptionMessage_thenEqual () {נסה {methodThatShouldThrowException (); להיכשל ("חריג לא נזרק"); } לתפוס (UnsupportedOperationException e) {assertEquals ("פעולה לא נתמכת", e.getMessage ()); }}

3.7. טוענים כי

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

במקרה זה, לטענה יש הודעת כשל אופציונלית, הערך בפועל ו- שידוך לְהִתְנַגֵד.

בואו נראה כיצד נוכל להשתמש בקביעה זו כדי לבדוק אם מערך מכיל ערכים מסוימים:

@ מבחן הריק הציבורי testAssertThatHasItems () {assertThat (Arrays.asList ("Java", "Kotlin", "Scala"), hasItems ("Java", "Kotlin")); } 

מידע נוסף על השימוש החזק ב- טוענים כי קביעה עם שידוך אובייקט, זמין ב- Testing with Hamcrest.

4. קביעות JUnit 5

JUnit 5 שמר על הרבה משיטות הקביעה של JUnit 4 תוך שהוא מוסיף כמה חדשים שמנצלים את התמיכה ב- Java 8.

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

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

נתחיל לסקור את הטענות הקיימות גם ב- JUnit 4.

4.1. assertArrayEquals

ה assertArrayEquals הקביעה מאמתת שהמערכים הצפויים והמערכים בפועל שווים:

@ מבחן ציבורי בטל כאשר AssertingArraysEquality_thenEqual () {char [] expect = {'J', 'u', 'p', 'i', 't', 'e', ​​'r'}; char [] actual = "צדק" .toCharArray (); assertArrayEquals (צפוי, ממשי, "מערכים צריכים להיות שווים"); }

אם המערכים אינם שווים, ההודעה "מערכים צריכים להיות שווים”יוצג כפלט.

4.2. assertEquals

למקרה שאנחנו רוצים לטעון את השניים צף הם שווים, אנחנו יכולים להשתמש בפשטות assertEquals טַעֲנָה:

@ מבחן ציבורי בטל כאשר AssertingEquality_thenEqual () {ריבוע צף = 2 * 2; מלבן צף = 2 * 2; assertEquals (מרובע, מלבן); }

עם זאת, אם אנו רוצים לטעון שהערך בפועל שונה בדלתא שהוגדרה מראש מהערך הצפוי, עדיין נוכל להשתמש assertEquals אבל עלינו להעביר את ערך הדלתא כפרמטר השלישי:

@ מבחן ציבורי בטל כאשר AssertingEqualityWithDelta_thenEqual () {ריבוע צף = 2 * 2; מלבן צף = 3 * 2; צף דלתא = 2; assertEquals (מרובע, מלבן, דלתא); }

4.3. לטעון נכון ו לטעון שקר

עם ה לטעון נכון קביעה, ניתן לוודא שהתנאים המסופקים הם נָכוֹן:

@Test הציבור בטל כאשרAssertingConditions_thenVerified () {assertTrue (5> 4, "5 גדול יותר מה -4"); assertTrue (null == null, "null שווה לאפס"); }

הודות לתמיכה בביטוי למבדה, ניתן לספק א ספק בוליאני לקביעה במקום א בוליאני מַצָב.

בואו נראה כיצד נוכל לקבוע את נכונותו של a ספק בוליאני משתמש ב לטעון שקר טַעֲנָה:

@Test public void givenBooleanSupplier_whenAssertingCondition_thenVerified () {BooleanSupplier condition = () -> 5> 6; assertFalse (תנאי, "5 אינו גדול מ- 6"); }

4.4. לטעון אפס ו לטעון NotNull

כשאנחנו רוצים לטעון שאובייקט לא ריק אנחנו יכולים להשתמש ב- לטעון NotNull טַעֲנָה:

@ מבחן ציבורי בטל כאשר AssertingNotNull_thenTrue () {כלב אובייקט = אובייקט חדש (); assertNotNull (כלב, () -> "הכלב לא צריך להיות אפס"); }

באופן הפוך, אנו יכולים להשתמש ב- לטעון אפס טענה לבדוק אם היא בפועל ריק:

@ מבחן ציבורי בטל כאשר AssertingNull_thenTrue () {Object cat = null; assertNull (חתול, () -> "החתול צריך להיות אפס"); }

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

4.5. assertSame ו assertNotSame

כשאנחנו רוצים לטעון שהצפוי והממש מתייחס לאותו הדבר לְהִתְנַגֵד, עלינו להשתמש ב- assertSame טַעֲנָה:

@ מבחן ציבורי בטל כאשר AssertingSameObject_thenSuccessfull () {שפת מחרוזת = "Java"; אופציונלי אופציונלי = Optional.of (שפה); assertSame (שפה, optional.get ()); }

באופן הפוך, אנו יכולים להשתמש ב- assertNotSame אחד.

4.6. לְהִכָּשֵׁל

ה לְהִכָּשֵׁל קביעה נכשלת בבדיקה עם הודעת הכישלון שסופקה כמו גם הסיבה הבסיסית. זה יכול להיות שימושי לסימון מבחן כאשר פיתוחו לא הושלם:

@Test הציבור בטל כאשר FailingATest_thenFailed () {// הבדיקה לא הושלמה נכשלה ("FAIL - הבדיקה לא הושלמה"); }

4.7. לטעון הכל

אחת הקבוצות החדשות שהוצגו ב- JUnit 5 היא טוענים.

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

בואו נגדיר קביעה מקובצת:

@ מבחן חלל ציבורי givenMultipleAssertion_whenAssertingAll_thenOK () {assertAll ("heading", () -> assertEquals (4, 2 * 2, "4 is 2 times 2"), () -> assertEquals ("java", "JAVA" .toLowerCase ()), () -> assertEquals (null, null, "null שווה לאפס")); }

הביצוע של קביעה קבוצה נקטע רק כאשר אחד מבכירי ההפעלה משליך חריג ברשימה השחורה (OutOfMemoryError לדוגמה).

4.8. assertIterableEquals

ה assertIterableEquals טוען כי הצפיות והניתובים האמיתיים שווים באופן עמוק.

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

בשיקול זה, בואו נראה כיצד נוכל לקבוע ששתי רשימות מסוגים שונים (רשימה מקושרת ו רשימת מערך לדוגמא) שווים:

@ מבחן חלל ציבורי givenTwoLists_whenAssertingIterables_thenEquals () {Iterable al = ArrayList new (asList ("Java", "Junit", "Test")); Iterable ll = חדש LinkedList (asList ("Java", "Junit", "Test")); assertIterableEquals (al, ll); }

באותו אופן של assertArrayEquals, אם שני הניתנים לשחזור הם אפסים, הם נחשבים שווים.

4.9. assertLinesMatch

ה assertLinesMatch טוען כי הרשימה הצפויה של חוּט תואם את הרשימה בפועל.

שיטה זו שונה מה- assertEquals ו assertIterableEquals מכיוון שלכל זוג קווים צפויים וממשיים הוא מבצע אלגוריתם זה:

  1. בדוק אם השורה הצפויה שווה לזו בפועל. אם כן זה ממשיך עם הזוג הבא
  2. להתייחס לשורה הצפויה כביטוי קבוע ומבצע בדיקה עם ה- חוּט.התאמות() שיטה. אם כן זה ממשיך עם הזוג הבא
  3. בדוק אם הקו הצפוי הוא סמן קדימה מהירה. אם כן, החל מהר קדימה וחזור על האלגוריתם משלב 1

בואו נראה כיצד נוכל להשתמש בקביעה זו כדי לקבוע ששתי רשימות של חוּט יש קווים תואמים:

@ מבחן פומבי בטל כאשר AssertingEqualityListOfStrings_thenEqual () {רשימה צפויה = asList ("Java", "\ d +", "JUnit"); רשימה בפועל = asList ("Java", "11", "JUnit"); assertLinesMatch (צפוי, ממשי); }

4.10. assertNotEquals

משלים ל assertEquals, ה assertNotEquals טענה טוענת שהערכים הצפויים והערכים בפועל אינם שווים:

@ מבחן ציבורי בטל כאשר AssertingEquality_thenNotEqual () {ערך שלם = 5; // תוצאה של אלגוריתם assertNotEquals (0, ערך, "התוצאה לא יכולה להיות 0"); }

אם שניהם כן ריק, הקביעה נכשלת.

4.11. טוען זורק

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

בואו נראה כיצד אנו יכולים לטעון חריג שנזרק:

@Test בטל כאשרAssertingException_thenThrown () {Throwable exception = assertThrows (IllegalArgumentException.class, () -> {throw new IllegalArgumentException ("הודעת חריג");}); assertEquals ("הודעת חריג", exception.getMessage ()); }

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

4.12. assertTimeout ו assertTimeout באופן מנע

במקרה שנרצה לקבוע כי ביצוע אספקה ביצוע מסתיים לפני נתון פסק זמן, אנחנו יכולים להשתמש ב- assertTimeout טַעֲנָה:

@ מבחן ציבורי בטל כאשר AssertingTimeout_thenNotExceeded () {assertTimeout (ofSeconds (2), () -> {// קוד שדורש פחות מ -2 דקות לביצוע Thread.sleep (1000);}); }

עם זאת, עם assertTimeout קביעה, ההפעלה המסופקת תבוצע באותו שרשור של קוד ההתקשרות. כתוצאה מכך, ביצוע הספק לא יופסל מקדימה אם תוקף הזמן הקצוב.

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

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

5. מסקנה

במדריך זה סקרנו את כל הטענות הקיימות ב- JUnit 4 ו- JUnit 5.

הדגשנו בקצרה את השיפורים שנעשו ב- JUnit 5, עם הצגת טענות חדשות ותמיכת lambdas.

כמו תמיד, קוד המקור השלם למאמר זה זמין באתר GitHub.