streamalism.org

1. סקירה כללית

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

הרעיון הוא להצהיר הצהרות טענות כמו שפה טבעית.

2. הגדרת Hamcrest

אנו יכולים להשתמש ב- Hamcrest עם Maven על ידי הוספת התלות הבאה שלנו pom.xml קוֹבֶץ:

 מבחן org.hamcrest java-hamcrest 2.0.0.0 

הגרסה האחרונה של הספרייה הזו נמצאת תמיד כאן.

3. התאמות ליבה נפוצות

3.1. הוא (T) ו הוא (Matcher)

ה הוא (T) לוקח אובייקט כפרמטר לבדיקת שוויון ו הוא (Matcher) לוקח התאמה נוספת המאפשרת הצהרת שוויון להיות אקספרסיבית יותר.

אנו יכולים להשתמש בכך כמעט בכל השיטות:

מחרוזת testString = "ליבת hamcrest"; assertThat (testString, is ("ליבת Hamcrest")); assertThat (testString, is (equalTo ("גרעין hamcrest"));

3.2. שווה ל- (T)

ה שווה ל- (T) לוקח אובייקט כפרמטר ובודק את השוויון שלו מול אובייקט אחר. זה משמש לעתים קרובות עם הוא (Matcher):

String actualString = "equalTo match"; רשימה actualList = Lists.newArrayList ("equalTo", "match"); assertThat (actualString, is (equalTo ("equalTo match"))); assertThat (actualList, is (equalTo (Lists.newArrayList ("equalTo", "match"))));

אנחנו יכולים גם להשתמש equalToObject (אופרנד אובייקט) - הבודק שוויון ואינו אוכף ששני אובייקטים צריכים להיות מאותו סוג סטטי:

מקור אובייקט = 100; assertThat (original, equalToObject (100));

3.3. לא (T) ו לא (Matcher)

ה לא (T) ו לא (Matcher) משמשים לבדיקת אי שוויון של אובייקטים נתונים. ראשית לוקח אובייקט כוויכוח ושני לוקח התאמה נוספת:

מחרוזת testString = "ממלכת טרוי"; assertThat (testString, not ("הממלכה הגרמנית")); assertThat (testString, is (not (equalTo ("הממלכה הגרמנית"))); assertThat (testString, is (not (instanceOf (Integer.class))));

3.4. nullValue () ו nullValue (Class)

ה nullValue () לבדוק ל ריק ערך מול האובייקט שנבדק. ה nullValue (Class) בודק אפסיות של אובייקט מסוג מחלקה נתון:

מספר שלם nullObject = null; assertThat (nullObject, is (nullValue ())); assertThat (nullObject, is (nullValue (Integer.class)));

3.5. notNullValue () ו notNullValue (Class)

אלה קיצור דרך לשימוש תכוף is (not (nullValue)). אלה בודקים אם אין שוויון של אובייקט או עם סוג המחלקה:

מספר שלם testNumber = 123; assertThat (testNumber, is (notNullValue ())); assertThat (testNumber, is (notNullValue (Integer.class)));

3.6. instanceOf (Class)

ה instanceOf (Class) תואם אם האובייקט שנבדק הוא מופע של המצוין מעמדסוּג.

כדי לאמת, שיטה זו מכנה באופן פנימי אתisIntance (אובייקט) שֶׁל מעמד מעמד:

assertThat ("instanceOf example", is (instanceOf (String.class)));

3.7. הוא(סוג כיתה)

ה isA (סוג מחלקה) הוא קיצור דרך לאמור לעיל instanceOf (Class). זה לוקח את אותו סוג של טיעון כמו instanceOf (Class):

assertThat ("דרוגון הוא הדרקון הגדול ביותר", isA (String.class));

3.8. sameInstance ()

ה sameInstance () תואם אם שני משתני הפניה מצביעים על אותו אובייקט בערימה:

String string1 = "Viseron"; מחרוזת מחרוזת 2 = מחרוזת 1; assertThat (string1, is (sameInstance (string2)));

3.9. כל (כיתה)

ה כל (כיתה)בודק אם המחלקה זהה לאובייקט בפועל:

assertThat ("מחרוזת הבדיקה", היא (any (String.class))); assertThat ("מחרוזת הבדיקה", היא (any (Object.class)));

3.10. allOf (Matcher ...) ו- anyOf (Matcher ...)

אנחנו יכולים להשתמש allOf (התאמה ...) לקבוע אם האובייקט בפועל תואם את כל התנאים שצוינו:

String testString = "אכילס חזק"; assertThat (testString, allOf (startsWith ("Achi"), endsWith ("ul"), containString ("Achilles")));

ה anyOf (התאמה ...) מתנהג כמו allOf (התאמה ...) אך תואם אם האובייקט שנבדק תואם את אחד התנאים שצוינו:

String testString = "הקטור הרג את אכילס"; assertThat (testString, anyOf (startsWith ("Hec"), containString ("baeldung")));

3.11. hasItem (T) ו hasItem (התאמה)

אלה תואמים אם נבדק ניתן לנידון אוסף תואם עם אובייקט או התאמה נתון בפנים hasItem () אוֹ hasItem (התאמה).

בואו להבין איך זה עובד:

רשימת רשימה = Lists.newArrayList ("java", "spring", "baeldung"); assertThat (list, hasItem ("java")); assertThat (רשימה, hasItem (isA (String.class)));

בדומה לכך, אנחנו יכולים גם לטעון נגד יותר מפריטים באמצעות hasItems (T ...) ו hasItems (התאמה ...):

רשימת רשימה = Lists.newArrayList ("java", "spring", "baeldung"); assertThat (list, hasItems ("java", "baeldung")); assertThat (list, hasItems (isA (String.class), endsWith ("ing")));

3.12. גם (Matcher) וגם (Matcher)

כפי שהשם מרמז, שניהם (Matcher) תואם כאשר שני התנאים שצוינו תואמים את האובייקט שנבדק:

מחרוזת testString = "daenerys targaryen"; assertThat (testString, both (startsWith ("daene")). ו- (containString ("ין")));

ו או (Matcher)תואם כאשר אחד מהתנאים שצוינו תואם את האובייקט שנבדק:

String testString = "daenerys targaryen"; assertThat (testString, או (startsWith ("tar")). או (containString ("targaryen")));

4. חוּט השוואה

אנחנו יכולים להשתמש containString (מחרוזת) אוֹ containStringIgnoringCase (מחרוזת) כדי לקבוע אם המחרוזת בפועל מכילה מחרוזת בדיקה:

מחרוזת testString = "Rhaegar Targaryen"; assertThat (testString, containString ("aegar")); assertThat (testString, containStringIgnoringCase ("AEGAR"));

אוֹ startsWith (מחרוזת) ו startsWithIgnoringCase (מחרוזת) כדי לקבוע אם המחרוזת בפועל מתחילה במחרוזת הבדיקה:

assertThat (testString, startsWith ("Rhae")); assertThat (testString, startsWithIgnoringCase ("rhae"));

אנחנו יכולים גם להשתמש מסתיים עם (מחרוזת) אוֹ endsWithIgnoringCase (מחרוזת) כדי לקבוע אם המחרוזת בפועל מסתיימת במחרוזת בדיקה:

assertThat (testString, endsWith ("aryen")); assertThat (testString, endsWithIgnoringCase ("ARYEN"));

5. מסקנה

במאמר זה דנו בשיטות שונות של CoreMatchers כיתה ב המקרסט סִפְרִיָה.

וכמו תמיד, ניתן למצוא את קוד המקור לדוגמאות ב- GitHub.