Hamcrest Common Core Matchers

1. Overzicht

In deze korte tutorial verkennen we de CoreMatchers klasse uit het populaire Hamcrest-framework voor het schrijven van eenvoudige en expressievere testcases.

Het idee is om beweerde uitspraken te laten lezen als natuurlijke taal.

2. Hamcrest-opstelling

We kunnen Hamcrest gebruiken met Maven door de volgende afhankelijkheid toe te voegen aan onze pom.xml het dossier:

 org.hamcrest java-hamcrest 2.0.0.0 test 

De laatste versie van deze bibliotheek is hier altijd te vinden.

3. Gemeenschappelijke Core Matchers

3.1. is (T) en is (Matcher)

De is (T) neemt een object als parameter om gelijkheid te controleren en is (Matcher) neemt een andere matcher waardoor de gelijkheidsverklaring expressiever is.

We kunnen dit met bijna alle methoden gebruiken:

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

3.2. gelijk aan (T)

De gelijk aan (T) neemt een object als parameter en controleert zijn gelijkheid met een ander object. Dit wordt vaak gebruikt bij is (Matcher):

String actualString = "equalTo match"; List actualList = Lists.newArrayList ("equalTo", "match"); assertThat (actualString, is (equalTo ("equalTo match"))); assertThat (actualList, is (equalTo (Lists.newArrayList ("equalTo", "match"))));

We kunnen ook gebruik maken van equalToObject (Object-operand) - die gelijkheid controleert en niet afdwingt dat twee objecten van hetzelfde statische type moeten zijn:

Object origineel = 100; assertThat (origineel, equalToObject (100));

3.3. niet (T) en niet (Matcher)

De niet (T) en niet (Matcher) worden gebruikt om de niet-gelijkheid van bepaalde objecten te controleren. Neem eerst een object als argument en neem ten tweede een andere matcher:

String testString = "troy koninkrijk"; assertThat (testString, niet ("duits koninkrijk")); assertThat (testString, is (not (equalTo ("duitse koninkrijk")))); assertThat (testString, is (not (instanceOf (Integer.class))));

3.4. nullwaarde () en nullValue (Klasse)

De nullwaarde () controleren op nul waarde ten opzichte van het onderzochte object. De nullValue (Klasse) controleert op nullabiliteit van een bepaald klassetype object:

Geheel getal nullObject = null; assertThat (nullObject, is (nullValue ())); assertThat (nullObject, is (nullValue (Integer.class)));

3.5. notNullValue () en notNullValue (Klasse)

Dit is een snelkoppeling naar veelgebruikte is (niet (nullValue)). Deze controleren op niet-nul-gelijkheid van een object of met het klassetype:

Geheel getal testNumber = 123; assertThat (testNumber, is (notNullValue ())); assertThat (testNumber, is (notNullValue (Integer.class)));

3.6. instanceOf (Klasse)

De instanceOf (Klasse) komt overeen als het onderzochte object een instantie is van het opgegeven Klassetype.

Ter verificatie roept deze methode intern hetisIntance (Object) van Klasse klasse:

assertThat ("instanceOf example", is (instanceOf (String.class)));

3.7. is een(Klasse type)

De isA (Klasse type) is een snelkoppeling naar het bovenstaande instanceOf (Klasse). Het heeft exact hetzelfde type argument nodig als een instanceOf (Klasse):

assertThat ("Drogon is de grootste draak", isA (String.class));

3.8. sameInstance ()

De sameInstance () komt overeen als twee referentievariabelen naar hetzelfde object in een heap verwijzen:

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

3.9. elke (klasse)

De elke (klasse)controleert of de klasse van hetzelfde type is als het werkelijke object:

assertThat ("test string", is (any (String.class))); assertThat ("test string", is (any (Object.class)));

3.10. allOf (Matcher ...) en anyOf (Matcher ...)

We kunnen gebruiken allOf (Matcher ...) om te bevestigen of het werkelijke object overeenkomt met alle opgegeven voorwaarden:

String testString = "Achilles is krachtig"; assertThat (testString, allOf (startsWith ("Achi"), endsWith ("ul"), containsString ("Achilles")));

De anyOf (Matcher ...) gedraagt ​​zich als allOf (Matcher ...) maar komt overeen als het onderzochte object overeenkomt met een van de gespecificeerde voorwaarden:

String testString = "Hector heeft Achilles gedood"; assertThat (testString, anyOf (startsWith ("Hec"), containsString ("baeldung")));

3.11. hasItem (T) en hasItem (Matcher)

Deze komen overeen als ze worden onderzocht Herhaalbaar verzameling komt overeen met een bepaald object of een matcher erin hasItem () of hasItem (Matcher).

Laten we begrijpen hoe dit werkt:

List list = Lists.newArrayList ("java", "spring", "baeldung"); assertThat (lijst, hasItem ("java")); assertThat (lijst, hasItem (isA (String.class)));

Evenzo we kunnen ook beweren tegen meer dan één items met behulp van hasItems (T ...) en hasItems (Matcher ...):

List list = Lists.newArrayList ("java", "spring", "baeldung"); assertThat (lijst, hasItems ("java", "baeldung")); assertThat (lijst, hasItems (isA (String.class), endsWith ("ing")));

3.12. beide (Matcher) en ofwel (Matcher)

Zoals de naam doet vermoeden, is de beide (Matcher) komt overeen als beide opgegeven voorwaarden overeenkomen met het onderzochte object:

String testString = "daenerys targaryen"; assertThat (testString, beide (startsWith ("daene")). en (containsString ("yen")));

en ofwel (Matcher)komt overeen als een van de opgegeven voorwaarden overeenkomt met het onderzochte object:

String testString = "daenerys targaryen"; assertThat (testString, ofwel (startsWith ("tar")). of (containsString ("targaryen")));

4. Draad Vergelijking

We kunnen gebruiken bevatString (tekenreeks) of bevatStringIgnoringCase (String) om te bevestigen of de daadwerkelijke tekenreeks een teststring bevat:

String testString = "Rhaegar Targaryen"; assertThat (testString, bevatString ("aegar")); assertThat (testString, bevatStringIgnoringCase ("AEGAR"));

Of startsWith (String) en startsWithIgnoringCase (String) om te bevestigen of de daadwerkelijke string begint met test string:

assertThat (testString, startsWith ("Rhae")); assertThat (testString, startsWithIgnoringCase ("rhae"));

We kunnen ook gebruik maken van endsWith (String) of endsWithIgnoringCase (String) om te bevestigen of de daadwerkelijke string eindigt met test string:

assertThat (testString, endsWith ("aryen")); assertThat (testString, endsWithIgnoringCase ("ARYEN"));

5. Conclusie

In dit artikel hebben we verschillende methoden van CoreMatchers les in Hamcrest bibliotheek.

En, zoals altijd, is de broncode voor de voorbeelden te vinden op GitHub.