A Hamcrest Number Matchers használata

1. Áttekintés

A Hamcrest statikus párosítókkal segíti az egységteszt állításainak egyszerűbbé és olvashatóbbá tételét. Itt kezdheti meg a rendelkezésre álló mérkőzések felfedezését.

Ebben a cikkben mélyebben belemerülünk a számhoz kapcsolódó párosítókba.

2. Beállítás

Hamcrest megszerzéséhez csak hozzá kell adnunk a következő Maven-függőséget pom.xml:

 org.hamcrest java-hamcrest 2.0.0.0 

A legújabb Hamcrest verzió megtalálható a Maven Central oldalon.

3. Proximity Matchers

Az első olyan páros, amelyet megnézünk, az ellenőrizze, hogy valamilyen elem közel van-e egy értékhez +/- hiba.

Formálisabban:

érték - hiba <= elem <= érték + hiba

Ha a fenti összehasonlítás igaz, az állítás elfogadható lesz.

Lássuk működés közben!

3.1. zárva Val vel Kettős Értékek

Tegyük fel, hogy van egy számunk, amelyet egy kettős változónak hívunk tényleges. És szeretnénk tesztelni, hogy tényleges közel 1 +/- 0,5.

Vagyis:

1 - 0,5 <= tényleges <= 1 + 0,5 0,5 <= tényleges <= 1,5

Most hozzunk létre egy egység tesztet a segítségével zárva páros:

@Test public void givenADouble_whenCloseTo_thenCorrect () {double double = 1.3; kettős operandus = 1; kettős hiba = 0,5; assertThat (tényleges, closeTo (operandus, hiba)); }

Mivel az 1,3 értéke 0,5 és 1,5 között van, a teszt sikeres lesz. Ugyanígy tesztelhetjük a negatív forgatókönyvet:

@Test public void givenADouble_whenNotCloseTo_thenCorrect () {duplán tényleges = 1,6; kettős operandus = 1; kettős hiba = 0,5; assertThat (tényleges, nem (closeTo (operandus, hiba))); }

Most nézzünk meg egy hasonló helyzetet más típusú változókkal.

3.2. zárva Val vel BigDecimal Értékek

zárva túlterhelt és ugyanúgy használható, mint a kettős értékekkel, de a BigDecimal tárgyakat:

@Test public void givenABigDecimal_whenCloseTo_thenCorrect () {BigDecimal actual = new BigDecimal ("1.0003"); BigDecimal operandus = new BigDecimal ("1"); BigDecimal hiba = new BigDecimal ("0,0005"); assertThat (tényleges, van (closeTo (operandus, hiba))); } @Test public void givenABigDecimal_whenNotCloseTo_thenCorrect () {BigDecimal actual = new BigDecimal ("1.0006"); BigDecimal operandus = new BigDecimal ("1"); BigDecimal hiba = new BigDecimal ("0,0005"); assertThat (tényleges, van (nem (closeTo (operandus, hiba)))); }

Kérjük, vegye figyelembe, hogy a van a matcher csak más díszítőket díszít anélkül, hogy extra logikát adna hozzá. Csak olvashatóbbá teszi az egész állítást.

Nagyjából ennyi a közelségbeli párosok számára. Ezután megnézzük a megrendelés párosait.

4. Parancsoljon párosokat

Ahogy a nevük mondja, ezek a mérkőzések segítenek állításokat tenni a sorrenddel kapcsolatban.

Öt közülük:

  • összehasonlítjaEqualTo
  • nagyobb, mint
  • nagyobbThanOrEqualTo
  • kevesebb, mint
  • kevesebbThanOrEqualTo

Nagyjából magától értetődőek, de nézzünk néhány példát.

4.1. Rendeljen párosokat a Egész V.alues

A leggyakoribb forgatókönyv az lenne ezeket a párosokat számokkal használva.

Tehát folytassuk és készítsünk néhány tesztet:

@Test public void given5_whenComparesEqualTo5_thenCorrect () {Öt egész = 5; assertThat (öt, összehasonlítjaEqualTo (öt)); } @Test public void given5_whenNotComparesEqualTo7_thenCorrect () {Hét egésze = 7; Öt egész = 5; assertThat (öt, nem (összehasonlítjaEqualTo (hét))); } @Test public void given7_whenGreaterThan5_thenCorrect () {Hét egésze = 7; Öt egész = 5; assertThat (hét, van (nagyobb, mint (öt))); } @Test public void given7_whenGreaterThanOrEqualTo5_thenCorrect () {Hét egésze = 7; Öt egész = 5; assertThat (hét, van (nagyobbThanOrEqualTo (öt))); } @Test public void given5_whenGreaterThanOrEqualTo5_thenCorrect () {Öt egész = 5; assertThat (öt, is (nagyobbThanOrEqualTo (öt))); } @Test public void given3_whenLessThan5_thenCorrect () {Három egész szám = 3; Öt egész = 5; assertThat (három, van (kevesebb, mint (öt))); } @Test public void given3_whenLessThanOrEqualTo5_thenCorrect () {Három egész szám = 3; Öt egész = 5; assertThat (három, van (kevesebbThanOrEqualTo (öt))); } @ Teszt nyilvános érvénytelen adott5_whenLessThanOrEqualTo5_thenCorrect () {Öt egész = 5; assertThat (öt, van (kevesebbThanOrEqualTo (öt))); }

Van értelme, igaz? Felhívjuk figyelmét, mennyire egyszerű megérteni, hogy az állítmányok mit állítanak.

4.2. Rendeljen párosokat a Húr Értékek

Annak ellenére, hogy a számok összehasonlításának teljes értelme van, sokszor hasznos összehasonlítani más típusú elemeket. Ezért rendelésillesztők alkalmazhatók bármely osztályra, amely a Hasonló felület.

Lássunk néhány példát Húrok:

@ Teszt nyilvános érvénytelen adottBenjamin_whenGreaterThanAmanda_thenCorrect () {String amanda = "Amanda"; Vonós benjamin = "Benjamin"; assertThat (benjamin, is (nagyobbThan (amanda))); } @ Teszt nyilvános érvénytelen adottAmanda_whenLessThanBenajmin_thenCorrect () {String amanda = "Amanda"; Vonós benjamin = "Benjamin"; assertThat (amanda, is (lessThan (benjamin))); }

Húr betűrendet valósít meg ben összehasonlítani módszer a Hasonló felület.

Tehát van értelme, hogy az „Amanda” szó a „Benjamin” szó elé kerül.

4.3. Rendeljen párosokat a LocalDate Értékek

Ugyanaz, mint a Húrok, összehasonlíthatjuk a dátumokat. Vessünk egy pillantást ugyanazokra a példákra, amelyeket fentebb készítettünk, de felhasználtunk LocalDate tárgyak:

@Test public void givenToday_whenGreaterThanYesterday_thenCorrect () {LocalDate today = LocalDate.now (); LocalDate tegnap = ma.minusDays (1); assertThat (ma van (nagyobbThan (tegnap))); } @Test public void givenToday_whenLessThanTomorrow_thenCorrect () {LocalDate today = LocalDate.now (); LocalDate holnap = ma.plusDays (1); assertThat (ma van (kevesebb (mint holnap))); }

Nagyon jó látni, hogy a kijelentés assertThat (ma van (kevesebb, mint (holnap))) közel áll a szokásos angol nyelvhez.

4.4. Rendeljen egyeztetőket egyedi osztályúes

Tehát miért ne hozhatnánk létre saját osztályunkat és valósíthatnánk meg Hasonló? Úgy, kihasználhatjuk az egyedi rendelési szabályokkal alkalmazandó rendelésillesztőket.

Kezdjük azzal, hogy létrehozunk egy Személy bab:

public class Személy {String név; int kor; // szabványos kivitelező, mérőeszközök és beállítók}

Most hajtsuk végre Hasonló:

public class Személy megvalósítja összehasonlítható {// ... @Orride public int CompareTo (Person o) {if (this.age == o.getAge ()) return 0; if (this.age> o.getAge ()) return 1; else visszatér -1; }}

A mi összehasonlítani a megvalósítás két embert hasonlít össze életkoruk szerint. Készítsünk most néhány új tesztet:

@ Teszt nyilvános érvénytelen adottAmanda_whenOlderThanBenjamin_thenCorrect () {Személy amanda = új Személy ("Amanda", 20); Személy benjamin = új személy ("Benjamin", 18); assertThat (amanda, is (nagyobbThan (benjamin))); } @Test public void givenBenjamin_whenYoungerThanAmanda_thenCorrect () {Személy amanda = új Személy ("Amanda", 20); Személy benjamin = új személy ("Benjamin", 18); assertThat (benjamin, is (lessThan (amanda))); }

A mérkőzések most a mi alapjaink szerint működnek összehasonlítani logika.

5. NaN Matcher

Hamcrest biztosítja egy extra számillesztõ annak meghatározásához, hogy valóban egy szám-e, nem pedig szám:

@ Teszt nyilvános érvénytelen adottNaN_whenIsNotANumber_thenCorrect () {kettős nulla = 0d; assertThat (nulla / nulla, van (notANumber ())); }

6. Következtetések

Amint látod, a számillesztők nagyon hasznosak a közös állítások egyszerűsítéséhez.

Sőt, általában a Hamcrest-mérkőzések magától értetődő és könnyen olvasható.

Mindez, valamint az illesztők és az egyedi összehasonlítási logika ötvözésének képessége hatékony eszközzé teszi őket a legtöbb projekt számára.

A cikk példáinak teljes megvalósítása megtalálható a GitHub oldalon.