Hogyan lehet TDD-t megvalósítani egy Java-listán
1. Áttekintés
Ebben az oktatóanyagban végigvezetünk egy szokást Lista megvalósítás a tesztvezérelt fejlesztési (TDD) folyamat segítségével.
Ez nem egy bevezetés a TDD-hez, ezért feltételezzük, hogy már van néhány alapvető elképzelése arról, hogy mit jelent, és tartós érdeklődéssel javítani.
Egyszerűen fogalmazva, A TDD egy olyan tervezőeszköz, amely lehetővé teszi számunkra, hogy tesztek segítségével irányítsuk megvalósításunkat.
Gyors felelősség kizárása - itt nem a hatékony megvalósítás létrehozására koncentrálunk - csak ürügyként használjuk a TDD gyakorlatok megjelenítésére.
2. Az első lépések
Először határozzuk meg az osztályunk csontvázat:
public class A CustomList megvalósítja a {private Object [] internal = {} listát; // üres végrehajtási módszerek}
A CustomList osztály hajtja végre a Lista interfész, ezért tartalmaznia kell az abban az interfészben deklarált összes módszer megvalósítását.
Az induláshoz csak üres testeket tudunk biztosítani ezekhez a módszerekhez. Ha egy metódusnak van visszatérési típusa, akkor tetszőleges ilyen típusú értéket adhatunk vissza, például nulla mert Tárgy vagy hamis mert logikai.
A rövidség kedvéért elhagyjuk az opcionális módszereket, valamint néhány olyan kötelező módszert, amelyeket nem gyakran használnak.
3. TDD ciklusok
Megvalósításunk fejlesztése a TDD-vel azt jelenti, hogy nekünk kell először hozzon létre teszteseteket, ezáltal meghatározva a megvalósításunk követelményeit. Csak majd létrehozzuk vagy kijavítjuk a megvalósítási kódot hogy ezek a tesztek sikeresek legyenek.
Nagyon leegyszerűsítve az egyes ciklusok három fő lépése a következő:
- Írás tesztek - meghatározza a követelményeket tesztek formájában
- Funkciók megvalósítása - hogy a tesztek sikeresek legyenek anélkül, hogy túlságosan a kód eleganciájára koncentrálnának
- Refaktorálás - javítsa a kódot, hogy megkönnyítse az olvasást és a karbantartást a tesztek teljesítése mellett
Végig fogjuk járni ezeket a TDD ciklusokat a Lista felület, kezdve a legegyszerűbbekkel.
4. A üres Módszer
A üres módszer valószínűleg a legegyszerűbb módszer, amelyet a Lista felület. Itt van a kezdő megvalósításunk:
@Orride public boolean isEmpty () {return false; }
Ez a kezdeti módszerdefiníció elég az összeállításhoz. Ennek a módszernek a teste javításra kényszerül, ha újabb és újabb teszteket adnak hozzá.
4.1. Az első ciklus
Írjuk meg az első tesztesetet, amely biztosítja, hogy a üres metódus visszatér igaz amikor a lista nem tartalmaz elemet:
@Test public void givenEmptyList_whenIsEmpty_thenTrueIsReturned () {List list = new CustomList (); assertTrue (list.isEmpty ()); }
Az adott teszt sikertelen, mivel üres metódus mindig visszatér hamis. Csak a visszatérési érték megfordításával tudjuk átadni:
@Orride public boolean isEmpty () {return true; }
4.2. A második ciklus
Annak megerősítésére, hogy a üres metódus visszatér hamis ha a lista nem üres, hozzá kell adnunk legalább egy elemet:
@Test public void givenNonEmptyList_whenIsEmpty_thenFalseIsReturned () {List list = new CustomList (); list.add (null); assertFalse (list.isEmpty ()); }
A hozzá módszerre van szükség. Itt van a hozzá módszerrel indulunk:
@Orride public boolean add (E elem) {return false; }
Ez a módszer nem működik, mivel a lista belső adatszerkezetében nem történik változás. Frissítsük a hozzáadott elem tárolására:
@Orride public boolean add (E element) {internal = new Object [] {element}; return false; }
Tesztünk még mindig nem sikerült, mivel üres A módszer nem lett továbbfejlesztve. Csináljuk meg:
@Orride public boolean isEmpty () {if (internal.length! = 0) {return false; } else {return true; }}
A nem üres teszt ezen a ponton teljesül.
4.3. Refaktorálás
Mindkét teszteset, amelyet eddig láttunk, megfelelt, de a üres módszer elegánsabb lehet.
Tegyük refaktorrá:
@Orride public boolean isEmpty () {return internal.length == 0; }
Láthatjuk, hogy a tesztek sikeresek, így a üres módszer teljes.
5. A méret Módszer
Ezzel kezdjük a méret metódus a CustomList osztály összeállításához:
@Orride public int size () {return 0; }
5.1. Az első ciklus
A meglévő felhasználásával hozzá módszerrel létrehozhatjuk az első tesztet a méret metódus, annak ellenőrzése, hogy az egyetlen elemet tartalmazó lista mérete 1:
@Test public void givenListWithAnElement_whenSize_thenOneIsReturned () {List list = new CustomList (); list.add (null); assertEquals (1, list.size ()); }
A teszt sikertelen, mivel méret módszer visszatér 0. Tegyük át egy új megvalósítással:
@Orride public int size () {if (isEmpty ()) {return 0; } else {return internal.length; }}
5.2. Refaktorálás
Refaktorálhatjuk a méret módszer elegánsabbá tételéhez:
@Orride public int size () {return internal.length; }
Ennek a módszernek a megvalósítása befejeződött.
6. A kap Módszer
Itt van a kap:
@Orride public E get (int index) {return null; }
6.1. Az első ciklus
Vizsgáljuk meg ennek a módszernek az első tesztjét, amely ellenőrzi a lista egyetlen elemének értékét:
@Test public void givenListWithAnElement_whenGet_thenThatElementIsReturned () {List list = new CustomList (); list.add ("baeldung"); Object element = list.get (0); assertEquals ("baeldung", elem); }
A teszt a kap módszer:
@Orride public E get (int index) {return (E) internal [0]; }
6.2. Javulás
Általában további teszteket adunk hozzá, mielőtt további fejlesztéseket hajtanánk végre a kap módszer. Ezeknek a teszteknek más módszerekre lenne szükségük Lista interfész a megfelelő állítások megvalósításához.
Ezek a más módszerek azonban még nem elég kiforrottak, ezért megszakítjuk a TDD ciklust, és létrehozzuk a kap módszer, ami valójában nem túl nehéz.
Ezt könnyű elképzelni kap ki kell vonni egy elemet a belső tömb a megadott helyen a index paraméter:
@Orride public E get (int index) {return (E) belső [index]; }
7. Az hozzá Módszer
Ez a hozzá a 4. szakaszban létrehozott módszer:
@Orride public boolean add (E element) {internal = new Object [] {element}; return false; }
7.1. Az első ciklus
Az alábbiakban bemutatunk egy egyszerű tesztet, amely ellenőrzi a hozzá:
@Test public void givenEmptyList_whenElementIsAdded_thenGetReturnsThatElement () {List list = new CustomList (); logikai sikertelen = list.add (null); assertTrue (sikerült); }
Módosítanunk kell a hozzá módszer a visszatéréshez igaz a teszt sikeres teljesítéséhez:
@Orride public boolean add (E element) {internal = new Object [] {element}; return true; }
Bár a teszt sikeres, a hozzá módszer még nem terjed ki minden esetre. Ha hozzáadunk egy második elemet a listához, a meglévő elem elvész.
7.2. A második ciklus
Itt van egy másik teszt, amely megköveteli, hogy a lista egynél több elemet tartalmazhasson:
@Test public void givenListWithAnElement_whenAnotherIsAdded_thenGetReturnsBoth () {List list = new CustomList (); list.add ("baeldung"); list.add (". com"); Object element1 = list.get (0); Object element2 = list.get (1); assertEquals ("baeldung", elem1); assertEquals (". com", elem2); }
A teszt nem fog sikerülni a hozzá A módszer a jelenlegi formájában nem engedélyez egynél több elem hozzáadását.
Változtassuk meg a megvalósítási kódot:
@Orride public boolean add (E element) {Object [] temp = Arrays.copyOf (belső, belső.hossz + 1); temp [belső.hossz] = elem; belső = hőmérséklet; return true; }
A megvalósítás elég elegáns, ezért nem kell átalakítanunk.
8. Következtetés
Ez az oktatópróba által vezérelt fejlesztési folyamaton ment keresztül egy egyedi rész létrehozása érdekében Lista végrehajtás. A TDD segítségével lépésről lépésre tudjuk megvalósítani a követelményeket, miközben a teszt lefedettségét nagyon magas szinten tartjuk. A megvalósítás garantáltan tesztelhető is, mivel a tesztek sikeres áthaladására hozták létre.
Vegye figyelembe, hogy az ebben a cikkben létrehozott egyéni osztály csak bemutató célokra használható, és nem szabad egy valós projektben elfogadni.
Az oktatóanyag teljes forráskódja, beleértve a rövidítés érdekében kihagyott tesztelési és megvalósítási módszereket, a GitHub oldalon található.