כיצד TDD יישום רשימות ב- Java

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

במדריך זה נעבור על מנהג אישי רשימה הטמעה באמצעות תהליך פיתוח מונחה מבחן (TDD).

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

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

כתב ויתור מהיר - אנחנו לא מתמקדים ביצירת יישום יעיל כאן - רק משתמשים בו כתירוץ להצגת שיטות TDD.

2. תחילת העבודה

ראשית, בואו נגדיר את השלד לכיתה שלנו:

המחלקה הציבורית מיישמת רשימת CustomList {אובייקט פרטי [] internal = {}; // שיטות יישום ריקות} 

ה רשימת CustomList הכיתה מיישמת את רשימה ולכן עליו לכלול יישומים לכל השיטות המוצהרות בממשק זה.

כדי להתחיל, אנחנו יכולים פשוט לספק גופות ריקות לשיטות אלה. אם לשיטה יש סוג החזרה, אנו יכולים להחזיר ערך שרירותי מסוג זה, כגון ריק ל לְהִתְנַגֵד אוֹ שֶׁקֶר ל בוליאני.

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

3. מחזורי TDD

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

באופן מאוד פשוט, שלושת השלבים העיקריים בכל מחזור הם:

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

נעבור את מחזורי TDD אלה לכמה שיטות של ה- רשימה ממשק, החל מהפשוטים ביותר.

4. ה זה ריק שיטה

ה זה ריק שיטה היא ככל הנראה השיטה הכי פשוטה שהוגדרה ב- רשימה מִמְשָׁק. הנה היישום ההתחלתי שלנו:

@Override בוליאני ציבורי isEmpty () {return false; }

הגדרת שיטה ראשונית זו מספיקה להרכבה. גוף שיטה זו "ייאלץ" להשתפר כאשר מתווספים עוד ועוד בדיקות.

4.1. המחזור הראשון

בואו נכתוב את מקרה הבדיקה הראשון שמוודא שה- זה ריק השיטה מחזירה נָכוֹן כאשר הרשימה אינה מכילה רכיב כלשהו:

@Test הציבור בטל givenEmptyList_whenIsEmpty_thenTrueIsReturned () {רשימה רשימה = רשימת Customly חדשה (); assertTrue (list.isEmpty ()); }

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

@ Override בוליאני ציבורי isEmpty () {return true; }

4.2. המחזור השני

כדי לאשר כי זה ריק השיטה מחזירה שֶׁקֶר כאשר הרשימה אינה ריקה, עלינו להוסיף לפחות אלמנט אחד:

@Test הציבור בטל givenNonEmptyList_whenIsEmpty_thenFalseIsReturned () {List list = רשימת Customly חדשה (); list.add (null); assertFalse (list.isEmpty ()); }

יישום של לְהוֹסִיף כעת נדרשת שיטה. הנה ה לְהוֹסִיף שיטה שאנחנו מתחילים איתה:

@ הוספה על בוליאני ציבורי הוסף (אלמנט E) {return false; }

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

@ Override הוסף בוליאני ציבורי (אלמנט E) {פנימי = אובייקט חדש [] {אלמנט}; להחזיר כוזב; }

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

@ Override בוליאני ציבורי isEmpty () {if (internal.length! = 0) {return false; } אחר {להחזיר נכון; }}

המבחן הלא ריק עובר בשלב זה.

4.3. ארגון מחדש

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

בואו נשקף את זה:

@Override בוליאני ציבורי isEmpty () {return internal.length == 0; }

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

5. ה גודל שיטה

זה היישום ההתחלתי שלנו של גודל שיטה המאפשרת את רשימת CustomList כיתה להרכיב:

@ גודל גודל ציבורי אינטראקטיבי () {להחזיר 0; }

5.1. המחזור הראשון

שימוש בקיים לְהוֹסִיף שיטה, אנו יכולים ליצור את המבחן הראשון עבור גודל שיטה, המאמת שגודל הרשימה עם אלמנט יחיד הוא 1:

@Test הציבור בטל givenListWithAnElement_whenSize_thenOneIsReturned () {List list = רשימת Customly חדשה (); list.add (null); assertEquals (1, list.size ()); }

המבחן נכשל כמו גודל השיטה חוזרת 0. בואו נעבור עם יישום חדש:

גודל הגודל הציבורי של @Override () {if (isEmpty ()) {return 0; } אחר {להחזיר פנימי. אורך; }}

5.2. ארגון מחדש

אנחנו יכולים לשקול מחדש את ה גודל שיטה כדי להפוך אותו לאלגנטי יותר:

@ גודל גודל ציבורי אינטראקטיבי () {החזר internal.length; }

יישום שיטה זו הושלם כעת.

6. ה לקבל שיטה

הנה היישום ההתחלתי של לקבל:

@ ביטול ציבורי E get (int index) {return null; }

6.1. המחזור הראשון

בואו נסתכל על הבדיקה הראשונה לשיטה זו, המאמתת את ערך האלמנט היחיד ברשימה:

@Test ציבורי בטל givenListWithAnElement_whenGet_thenThatElementIsReturned () {List list = רשימת CustomLists חדשה (); list.add ("באלדונג"); אלמנט אובייקט = list.get (0); assertEquals ("baeldung", אלמנט); }

המבחן יעבור עם יישום זה של לקבל שיטה:

@ עקוף לציבור E get (int index) {return (E) פנימי [0]; }

6.2. הַשׁבָּחָה

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

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

קל לדמיין זאת לקבל חייב לחלץ אלמנט מה- פְּנִימִי מערך במיקום שצוין באמצעות אינדקס פָּרָמֶטֶר:

@ עקוף לציבור E get (int index) {return (E) פנימי [index]; }

7. ה לְהוֹסִיף שיטה

זה לְהוֹסִיף השיטה שיצרנו בסעיף 4:

@ הוספה על בוליאני ציבורי הוסף (אלמנט E) {פנימי = אובייקט חדש [] {אלמנט}; להחזיר כוזב; }

7.1. המחזור הראשון

להלן מבחן פשוט המאמת את ערך ההחזר של לְהוֹסִיף:

@Test הציבור בטל givenEmptyList_whenElementIsAdded_thenGetReturnsThatElement () {רשימה רשימה = רשימת CustomLists חדשה (); בוליאני הצליח = list.add (null); assertTrue (הצליח); }

עלינו לשנות את לְהוֹסִיף שיטה לחזור נָכוֹן למבחן לעבור:

@ הוספה על בוליאני ציבורי הוסף (אלמנט E) {פנימי = אובייקט חדש [] {אלמנט}; לחזור אמיתי; }

למרות שהמבחן עובר, ה לְהוֹסִיף השיטה עדיין לא מכסה את כל המקרים. אם נוסיף אלמנט שני לרשימה, האלמנט הקיים יאבד.

7.2. המחזור השני

הנה מבחן נוסף שמוסיף את הדרישה שהרשימה יכולה להכיל יותר מאלמנט אחד:

@Test הציבור בטל givenListWithAnElement_whenAnotherIsAdded_thenGetReturnsBoth () {רשימה רשימה = רשימת CustomLists חדשה (); list.add ("באלדונג"); list.add (". com"); אובייקט element1 = list.get (0); אובייקט element2 = list.get (1); assertEquals ("baeldung", element1); assertEquals (". com", element2); }

הבדיקה תיכשל מאז לְהוֹסִיף השיטה בצורתה הנוכחית אינה מאפשרת להוסיף יותר מאלמנט אחד.

בואו נשנה את קוד ההטמעה:

@ הוספה של בוליאני ציבורי הוספה (אלמנט E) {אובייקט [] temp = Arrays.copyOf (פנימי, פנימי.אורך + 1); temp [internal.length] = אלמנט; פנימי = temp; לחזור אמיתי; }

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

8. מסקנה

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

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

את קוד המקור המלא של מדריך זה, כולל שיטות הבדיקה וההטמעה שנשארו למען הקיצור, ניתן למצוא באתר GitHub.