streamalism.org

1. Bemutatkozás

Ebben a cikkben részletesen megvizsgáljuk a JUnit-en belül elérhető állításokat.

A JUnit 4-ről az JUnit 5-re való áttérés és az Útmutató az 5-ös JUnit cikkekhez való áttérést követően most a 4-es és 5-ös JUnit-ben elérhető különböző állítások részleteibe megyünk.

Emellett kiemeljük az állítások JUnit 5 segítségével végzett fejlesztéseit is.

2. Állítások

Az állítások hasznos módszerek a feltételek érvényesítésének támogatására a tesztekben; ezek a módszerek a Állítsd osztály, a JUnit 4-ben, és a Állítások az egyik, az 5. JUnit-ben.

A teszt és az állítások olvashatóságának növelése érdekében mindig ajánlott import statikusan az adott osztály. Ily módon közvetlenül hivatkozhatunk magára az állítási módszerre, anélkül, hogy előtagként reprezentálnánk az osztályt.

Kezdjük feltárni a JUnit 4 segítségével elérhető állításokat.

3. Állítások a JUnit 4-ben

A könyvtár ezen verziójában állítások állnak rendelkezésre minden primitív típushoz, Tárgyak, és tömbök (primitívek vagy Tárgyak).

Az állításon belül a paraméterek sorrendje a várható érték, amelyet a tényleges érték követ; opcionálisan az első paraméter lehet a Húr üzenet, amely az értékelt feltétel üzenetkimenetét jelenti.

Csak egy kissé különbözik a definíció módjától állítsa azt állításokat, de később kitérünk rá.

Kezdjük a assertEquals egy.

3.1. assertEquals

A assertEquals állítás igazolja, hogy a várható és a tényleges érték megegyezik:

@Test public void whenAssertingEquality_thenEqual () {String várható = "Baeldung"; Karaktersorozat = "Baeldung"; assertEquals (várható, tényleges); }

Megadható egy üzenet is, amelyet megjeleníteni kell, ha az állítás sikertelen:

assertEquals ("hiba - a karakterláncok nem egyenlőek", várható, tényleges);

3.2. assertArrayEquals

Ha azt akarjuk állítani, hogy két tömb egyenlő, használhatjuk a assertArrayEquals:

@Test public void whenAssertingArraysEquality_thenEqual () {char [] várható = {'J', 'u', 'n', 'i', 't'}; char [] tényleges = "Junit" .toCharArray (); assertArrayEquals (várható, tényleges); }

Ha mindkét tömb nulla, az állítás egyenlőnek fogja tekinteni őket:

@Test public void givenNullArrays_whenAssertingArraysEquality_thenEqual () {int [] várható = null; int [] tényleges = null; assertArrayEquals (várható, tényleges); }

3.3. assertNotNull és állítsaNull

Amikor tesztelni akarjuk, hogy van-e egy tárgy nulla használhatjuk a állítsaNull állítás:

@Test public void whenAssertingNull_thenTrue () {Object car = null; assertNull ("Az autó nullának kell lennie", autó); }

Ellenkezőleg, ha azt akarjuk állítani, hogy egy objektumnak nem szabad nullának lennie, akkor használhatjuk a assertNotNull állítás.

3.4. assertNotSame és assertSame

Val vel assertNotSame, ellenőrizhető, hogy két változó nem ugyanarra az objektumra utal-e:

@Test public void whenAssertingNotSameObject_thenDifferent () {Object cat = new Object (); Object dog = new Object (); assertNotSame (macska, kutya); }

Ellenkező esetben, ha ellenőrizni akarjuk, hogy két változó ugyanarra az objektumra vonatkozik-e, használhatjuk a assertSame állítás.

3.5. assertTrue és assertFalse

Abban az esetben, ha ellenőrizni akarjuk, hogy egy bizonyos feltétel teljesül-e igaz vagy hamis, illetve használhatjuk a assertTrue állítás vagy a assertFalse egy:

@Test public void whenAssertingConditions_thenVerified () {assertTrue ("5 nagyobb, mint 4", 5> 4); assertFalse ("5 nem nagyobb, mint 6", 5> 6); }

3.6. nem sikerül

A nem sikerül az állítás elbukik egy próbadobással AssertionFailedError. Fel lehet használni annak ellenőrzésére, hogy egy tényleges kivétel eldőlt, vagy amikor egy tesztet sikertelenül szeretnénk végrehajtani a fejlesztése során.

Lássuk, hogyan használhatjuk az első forgatókönyvben:

@Test public void whenCheckingExceptionMessage_thenEqual () {try {methodThatShouldThrowException (); kudarc ("Kivételt nem dobtak"); } catch (UnsupportedOperationException e) {assertEquals ("A művelet nem támogatott", e.getMessage ()); }}

3.7. állítsa azt

A állítsa azt az állítás az egyetlen a JUnit 4-ben, amelynek a többi állításhoz képest fordított sorrendje van a paramétereknek.

Ebben az esetben az állításnak van egy opcionális hibaüzenete, a tényleges értéke és a Matcher tárgy.

Nézzük meg, hogyan használhatjuk ezt az állítást annak ellenőrzésére, hogy egy tömb tartalmaz-e bizonyos értékeket:

@Test public void testAssertThatHasItems () {assertThat (Arrays.asList ("Java", "Kotlin", "Scala"), hasItems ("Java", "Kotlin")); } 

Kiegészítő információk a állítsa azt állítás azzal Matcher objektum, elérhető a Tesztelés a Hamcrest címen.

4. JUnit 5 állítások

Az 5. JUnit megtartotta a JUnit 4 számos állítási módszerét, miközben néhány újat adott hozzá, amelyek kihasználják a Java 8 támogatás előnyeit.

A könyvtár ezen verziójában is állítások állnak rendelkezésre minden primitív típushoz, Tárgyak, és tömbök (akár primitívek, akár tárgyak).

Az állítások paramétereinek sorrendje megváltozott, a kimeneti üzenet paraméterét utolsó paraméterként mozgatva. A Java 8 támogatásának köszönhetően a kimeneti üzenet lehet a Támogató, lehetővé téve annak lusta értékelését.

Kezdjük áttekinteni a 4. JUnit-ben is elérhető állításokat.

4.1. assertArrayEquals

A assertArrayEquals állítás igazolja, hogy a várható és a tényleges tömb megegyezik:

@Test public void whenAssertingArraysEquality_thenEqual () {char [] várható = {'J', 'u', 'p', 'i', 't', 'e', ​​'r'}; char [] tényleges = "Jupiter" .toCharArray (); assertArrayEquals (várható, tényleges, "A tömbnek egyenlőnek kell lennie"); }

Ha a tömbök nem egyenlőek, akkor aA tömböknek egyenlőnek kell lenniük”Jelenik meg kimenetként.

4.2. assertEquals

Ha azt akarjuk állítani, hogy ez a kettő lebeg egyenlőek, használhatjuk az egyszerűt assertEquals állítás:

@Test public void whenAssertingEquality_thenEqual () {float square = 2 * 2; úszó téglalap = 2 * 2; assertEquals (négyzet, téglalap); }

Ha azonban azt akarjuk állítani, hogy a tényleges érték egy előre definiált delttal különbözik a várható értéktől, akkor is használhatjuk a assertEquals de a delta értéket át kell adnunk harmadik paraméterként:

@Test public void whenAssertingEqualityWithDelta_thenEqual () {float square = 2 * 2; úszó téglalap = 3 * 2; úszó delta = 2; assertEquals (négyzet, téglalap, delta); }

4.3. assertTrue és assertFalse

A ... val assertTrue állítással ellenőrizni lehet a mellékelt feltételeket igaz:

@Test public void whenAssertingConditions_thenVerified () {assertTrue (5> 4, "5 nagyobb, mint 4"); assertTrue (null == null, "null egyenlő null"); }

A lambda kifejezés támogatásának köszönhetően lehetséges a BooleanSupplier az állításra a helyett logikai feltétel.

Lássuk, miként állíthatjuk az a helyességét BooleanSupplier használni a assertFalse állítás:

@Test public void givenBooleanSupplier_whenAssertingCondition_thenVerified () {BooleanSupplier feltétel = () -> 5> 6; assertFalse (feltétel: "5 nem nagyobb, mint 6"); }

4.4. állítsaNull és assertNotNull

Amikor azt akarjuk állítani, hogy egy tárgy nem az nulla használhatjuk a assertNotNull állítás:

@Test public void whenAssertingNotNull_thenTrue () {Object dog = new Object (); assertNotNull (kutya, () -> "A kutya nem lehet null"); }

Épp ellenkezőleg, használhatjuk a állítsaNull állítás annak ellenőrzésére, hogy a tényleges-e nulla:

@Test public void whenAssertingNull_thenTrue () {Object cat = null; assertNull (cat, () -> "A macskának nullának kell lennie"); }

Mindkét esetben a hibaüzenetet lusta módon fogjuk letölteni, mivel a Támogató.

4.5. assertSame és assertNotSame

Amikor azt akarjuk állítani, hogy a várható és a tényleges ugyanazra vonatkozik Tárgy, használnunk kell a assertSame állítás:

@Test public void whenAssertingSameObject_thenSuccessfull () {String language = "Java"; Opcionális választható = Opcionális. (Nyelv); assertSame (nyelv, opcionális.get ()); }

Épp ellenkezőleg, használhatjuk a assertNotSame egy.

4.6. nem sikerül

A nem sikerül az állítás sikertelen lesz egy teszten a mellékelt hibaüzenettel, valamint a mögöttes okkal. Ez hasznos lehet egy teszt megjelölésére, amikor a fejlesztés még nem fejeződött be:

@Test public void whenFailingATest_thenFailed () {// A teszt nem fejeződött be sikertelen ("FAIL - teszt nem fejeződött be"); }

4.7. assertAll

Az 5. JUnit-ben bevezetett új állítások egyike assertAll.

Ez az állítás lehetővé teszi csoportosított állítások létrehozását, ahol az összes állítást végrehajtják, és azok hibáit együtt jelentik. Részletesen, ez az állítás elfogad egy címsort, amelyet a következő üzenetlánc tartalmaz MultipleFailureError, és a Folyam nak,-nek Végrehajtható.

Definiáljunk egy csoportosított állítást:

@Test public void givenMultipleAssertion_whenAssertingAll_thenOK () {assertAll ("title", () -> assertEquals (4, 2 * 2, "4 is 2x 2"), () -> assertEquals ("java", "JAVA" .toLowerCase ()), () -> assertEquals (null, null, "null nullával egyenlő")); }

A csoportosított állítás végrehajtása csak akkor szakad meg, ha az egyik futtatható fájl feketelistára tett kivételt dob ​​(OutOfMemoryError például).

4.8. assertIterableEquals

A assertIterableEquals azt állítja, hogy a várható és a tényleges iterable mélyen egyenlő.

Annak érdekében, hogy egyenlő legyen, mindkét iterálhatónak egyenlő elemeket kell ugyanabban a sorrendben visszaadnia, és nem szükséges, hogy a két iterable azonos típusú legyen, hogy egyenlőek legyenek.

Ezzel a megfontolással lássuk, hogyan állíthatjuk, hogy két különböző típusú lista (LinkedList és Tömb lista például) egyenlőek:

@Test public void givenTwoLists_whenAssertingIterables_thenEquals () {Iterable al = new ArrayList (asList ("Java", "Junit", "Test")); Iterable ll = new LinkedList (asList ("Java", "Junit", "Test")); assertIterableEquals (al, ll); }

Ugyanígy a assertArrayEquals, ha mindkét iteráció null, akkor egyenlőnek tekintjük őket.

4.9. assertLinesMatch

A assertLinesMatch azt állítja, hogy a Húr megfelel a tényleges listának.

Ez a módszer eltér a assertEquals és assertIterableEquals mivel a várható és a tényleges vonalak minden párjára elvégzi ezt az algoritmust:

1. ellenőrizze, hogy a várható vonal megegyezik-e a tényleges vonallal. Ha igen, akkor a következő párral folytatódik
2. a várt sort reguláris kifejezésként kezeli, és ellenőrzést végez a Húr.mérkőzések () módszer. Ha igen, akkor a következő párral folytatódik
3. ellenőrizze, hogy a várt vonal gyors előrejelző-e. Ha igen, alkalmazza a gyors előre lépést, és ismételje meg az algoritmust az 1. lépéstől

Nézzük meg, hogyan használhatjuk ezt az állítást annak a két listának az érvényesítésére Húr megfelelő sorok vannak:

@Test public void whenAssertingEqualityListOfStrings_thenEqual () {List várható = asList ("Java", "\ d +", "JUnit"); Sorolja fel a tényleges = asList listát ("Java", "11", "JUnit"); assertLinesMatch (várható, tényleges); }

4.10. assertNotEquals

Kiegészíti a assertEquals, a assertNotEquals Az állítás azt állítja, hogy a várható és a tényleges érték nem egyenlő:

@Test public void whenAssertingEquality_thenNotEqual () {Egész szám = 5; // algoritmus eredménye assertNotEquals (0, érték, "Az eredmény nem lehet 0"); }

Ha mindkettő nulla, az állítás kudarcot vall.

4.11. assertThrows

Az egyszerűség és az olvashatóság növelése érdekében az új assertThrows Az állítás lehetővé teszi számunkra, hogy világos és egyszerű módon állítsuk be, ha egy futtatható fájl eldobja a megadott kivétel típusát.

Lássuk, miként érvényesíthetjük a dobott kivételt:

@Test void whenAssertingException_thenThrown () {Dobható kivétel = assertThrows (IllegalArgumentException.class, () -> {dobja az új IllegalArgumentException ("Kivételüzenet");}); assertEquals ("Kivételüzenet", kivétel.getMessage ()); }

Az állítás sikertelen lesz, ha nem dobnak kivételt, vagy ha más típusú kivételt dobnak.

4.12. assertTimeout és assertTimeoutPreemptively

Abban az esetben, ha azt akarjuk állítani, hogy egy teljesített végrehajtása Végrehajtható adott előtt véget ér Időtúllépés, használhatjuk a assertTimeout állítás:

@Test public void whenAssertingTimeout_thenNotExceeded () {assertTimeout (ofSeconds (2), () -> {// kód, amely kevesebb mint 2 percet igényel a Thread.sleep (1000);}) végrehajtásához }

Azonban a assertTimeout állítással, a mellékelt futtatható fájl a hívó kód ugyanazon szálában fog végrehajtódni. Következésképpen a szállító végrehajtása nem kerül megszakításra, ha túllépik az időkorlátot.

Abban az esetben, ha biztosak akarunk lenni abban, hogy a futtatható fájl végrehajtása megszakad, ha túllépi az időtúllépést, használhatjuk a assertTimeoutPreemptively állítás.

Mindkét állítás elfogadható, an helyett Végrehajtható, a ThrowingSupplier, amely minden olyan általános kódblokkot képvisel, amely egy objektumot ad vissza, és amely potenciálisan a Dobható.

5. Következtetés

Ebben az oktatóanyagban áttekintettük a JUnit 4 és az JUnit 5 összes állítását.

Röviden kiemeltük az 5. JUnit fejlesztéseit, új állítások bevezetésével és a lambdas támogatásával.

Mint mindig, a cikk teljes forráskódja elérhető a GitHubon.