Hamcrest Common Core Matchers

1. Áttekintés

Ebben a gyors bemutatóban felfedezzük a CoreMatchers osztály a népszerű Hamcrest keretrendszerből egyszerű és kifejezőbb tesztesetek megírásához.

Az ötlet az, hogy az állításokat természetes nyelvként olvassák el.

2. Hamcrest Setup

Használhatjuk a Hamcrest-et Maven-nel, ha hozzáadjuk a következő függőséget pom.xml fájl:

 org.hamcrest java-hamcrest 2.0.0.0 teszt 

A könyvtár legújabb verziója mindig itt található.

3. Gyakori alapvető mérkőzések

3.1. (T) és van (Matcher)

A (T) objektumot vesz paraméterként az egyenlőség ellenőrzésére és van (Matcher) megkövetel egy másik mérkőzést, lehetővé téve az egyenlőség megállapításának kifejezőbbé tételét.

Ezt szinte az összes módszerrel alkalmazhatjuk:

String testString = "hamcrest mag"; assertThat (testString, is ("hamcrest mag")); assertThat (testString, is (equalTo ("hamcrest mag")));

3.2. egyenlőTo (T)

A egyenlőTo (T) egy objektumot vesz paraméterként és ellenőrzi annak egyenlőségét egy másik objektummal. Ezt gyakran használják a van (Matcher):

String actualString = "equTo match"; List actualList = Lists.newArrayList ("egyenlőTo", "egyezés"); assertThat (actualString, is (equalTo ("egyenlőTo match"))); assertThat (actualList, is (egyenlőTo (Lists.newArrayList ("egyenlőTo", "egyezés"))));

Használhatjuk is equToObject (Objektum operandus) - amely ellenőrzi az egyenlőséget és nem érvényesíti, hogy két objektumnak azonos statikus típusúnak kell lennie:

Objektum eredeti = 100; assertThat (eredeti, egyenlőToObject (100));

3.3. nem (T) és nem (egyező)

A nem (T) és nem (Matcher) az adott objektumok nem egyenlőségének ellenőrzésére szolgálnak. Először egy objektumot vesz fel argumentumként, másodszor pedig egy másik párosítót:

String testString = "troy királyság"; assertThat (testString, nem ("német királyság")); assertThat (testString, is (nem (equTo ("német királyság")))); assertThat (testString, is (nem (instanceOf (Integer.class))));

3.4. nullValue () és nullValue (osztály)

A nullValue () ellenőrizze nulla érték a vizsgált objektummal szemben. A nullValue (osztály) ellenőrzi az adott osztálytípusú objektum érvénytelenségét:

Egész nullObject = null; assertThat (nullObject, is (nullValue ())); assertThat (nullObject, is (nullValue (Egész.osztály)));

3.5. notNullValue () és notNullValue (osztály)

Ezek a gyakran használt parancsikonok is (not (nullValue)). Ezek ellenőrzik az objektum vagy az osztálytípus nem null-egyenlőségét:

Egész szám teszt = 123; assertThat (testNumber, is (notNullValue ())); assertThat (testNumber, is (notNullValue (Integer.class)));

3.6. instanceOf (osztály)

A instanceOf (osztály) egyezik, ha a vizsgált objektum a megadott példánya Osztálytípus.

Az ellenőrzéshez ez a módszer belsőleg hívja aisIntance (Object) nak,-nek Osztály osztály:

assertThat ("exampleOf example", is (instanceOf (String.osztály)));

3.7. egy(Osztálytípus)

A isA (osztálytípus) egy parancsikon a fentiekhez instanceOf (osztály). Pontosan ugyanolyan típusú argumentumra van szükség, mint egy instanceOf (osztály):

assertThat ("A Drogon a legnagyobb sárkány", isA (String.osztály));

3.8. sameInstance ()

A sameInstance () egyezik, ha két referencia változó ugyanarra az objektumra mutat egy kupacban:

String string1 = "Viseron"; Karakterlánc string2 = string1; assertThat (string1, is (sameInstance (string2)));

3.9. bármely (osztály)

A bármely (osztály)ellenőrzi, hogy az osztály azonos-e a tényleges objektummal:

assertThat ("teszt karaktersorozat", is (bármilyen (String.osztály))); assertThat ("teszt karaktersorozat", az (bármelyik (Object.class)));

3.10. allOf (Matcher…) és anyOf (Matcher…)

Tudjuk használni allOf (Matcher…) annak igazolása, hogy a tényleges objektum megfelel-e az összes megadott feltételnek:

String testString = "Achilles hatalmas"; assertThat (testString, allOf (startsWith ("Achi"), endWith ("ul"), tartalmazzaString ("Achilles")));

A anyOf (Matcher…) úgy viselkedik allOf (Matcher…) de egyezik, ha a vizsgált objektum megfelel a megadott feltételek bármelyikének:

String testString = "Hector megölte Achilles-t"; assertThat (testString, anyOf (startsWith ("Hec"), tartalmazzaString ("baeldung")));

3.11. hasItem (T) és hasItem (egyező)

Ezek egyeznek, ha a vizsgált Iterálható a gyűjtemény megfelel az adott tárgynak vagy a benne lévő párosítónak hasItem () vagy hasItem (egyező).

Értsük meg, hogyan működik ez:

Lista lista = Lists.newArrayList ("java", "tavasz", "baeldung"); assertThat (lista, hasItem ("java")); assertThat (lista, hasItem (isA (Karakterlánc.osztály)));

Hasonlóképpen, mi is tehetjük több elem ellen is állíthat a hasItems (T…) és hasItems (Matcher…):

Lista lista = Lists.newArrayList ("java", "tavasz", "baeldung"); assertThat (lista, hasItems ("java", "baeldung")); assertThat (list, hasItems (isA (String.osztály), endWith ("ing")));

3.12. mind (Matcher), mind pedig (Matcher)

Ahogy a neve is mutatja, a mindkettő (Matcher) akkor egyezik, ha mindkét megadott feltétel megegyezik a vizsgált objektummal:

String testString = "daenerys targaryen"; assertThat (testString, mind (startWith ("daene")). és (tartalmazzaString ("jen")));

és vagy (Matcher)akkor egyezik, ha a megadott feltételek bármelyike ​​megegyezik a vizsgált objektummal:

String testString = "daenerys targaryen"; assertThat (testString, vagy (startWith ("tar"))). vagy (tartalmazzaString ("targaryen")));

4. Húr Összehasonlítás

Tudjuk használni tartalmazString (karakterlánc) vagy tartalmazStringIgnoringCase (karakterlánc) állítani, ha a tényleges karakterlánc tartalmaz tesztláncot:

String testString = "Rhaegar Targaryen"; assertThat (testString, tartalmazzaString ("aegar")); assertThat (testString, tartalmazzaStringIgnoringCase ("AEGAR"));

Vagy startsWith (karakterlánc) és startsWithIgnoringCase (karakterlánc) állítani, ha a tényleges karakterlánc teszt karaktersorozattal kezdődik:

assertThat (testString, kezdődik ("Rhae")); assertThat (testString, startsWithIgnoringCase ("rhae"));

Használhatjuk is vége (String) vagy endWithIgnoringCase (karakterlánc) állítani, ha a tényleges karakterlánc teszt-karakterlánccal végződik:

assertThat (testString, végződik ("aryen")); assertThat (testString, endWithIgnoringCase ("ARYEN"));

5. Következtetés

Ebben a cikkben megvitattuk a különböző módszereket CoreMatchers osztályban Hamcrest könyvtár.

És mint mindig, a példák forráskódja megtalálható a GitHubon.