Hamcrest Common Core Matchers

1. Panoramica

In questo breve tutorial, esploreremo la classe CoreMatchers dal popolare framework Hamcrest per scrivere casi di test semplici e più espressivi.

L'idea è di far leggere le affermazioni come un linguaggio naturale.

2. Configurazione Hamcrest

Possiamo usare Hamcrest con Maven aggiungendo la seguente dipendenza al nostro file pom.xml :

 org.hamcrest java-hamcrest 2.0.0.0 test 

L'ultima versione di questa libreria è sempre disponibile qui.

3. Common Core Matchers

3.1. è (T) ed è (Matcher)

Is (T) accetta un oggetto come parametro per verificare l'uguaglianza e is (Matcher) accetta un altro matcher che consente all'istruzione di uguaglianza di essere più espressiva.

Possiamo usarlo con quasi tutti i metodi :

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

3.2. uguale a (T)

L' equalTo (T) accetta un oggetto come parametro e controlla la sua uguaglianza rispetto a un altro oggetto. Questo è spesso usato con 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"))));

Possiamo anche usare equalToObject (Object operand) - che controlla l'uguaglianza e non impone che due oggetti debbano essere dello stesso tipo statico:

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

3.3. not (T) e non (Matcher)

Il non (T) e il non (Matcher) vengono utilizzati per verificare la non uguaglianza di oggetti dati. Prima prende un oggetto come argomento e il secondo prende un altro matcher:

String testString = "troy kingdom"; assertThat(testString, not("german kingdom")); assertThat(testString, is(not(equalTo("german kingdom")))); assertThat(testString, is(not(instanceOf(Integer.class))));

3.4. nullValue () e nullValue (Classe)

Il nullValue () verifica il valore null rispetto all'oggetto esaminato. Il nullValue (Class) controlla il nullability di un dato tipo di classe oggetto:

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

3.5. notNullValue () e notNullValue (Class)

Si tratta di una scorciatoia per utilizzare di frequente is (not (nullValue)) . Questi verificano l'uguaglianza non nulla di un oggetto o con il tipo di classe:

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

3.6. instanceOf (Classe)

L'instanceof (Class) corrisponde se l'oggetto in esame è un'istanza della specifica classegenere.

Per verificare, questo metodo chiama internamente isIntance (Object) della classe Class :

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

3.7. isA (tipo di classe)

L' Isa (tipo Class) è una scorciatoia a quanto sopra instanceof (Class) . Accetta lo stesso identico tipo di argomento di instanceOf (Class) :

assertThat("Drogon is biggest dragon", isA(String.class));

3.8. sameInstance ()

La sameInstance () corrisponde se due variabili di riferimento puntano allo stesso oggetto in un heap:

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

3.9. qualsiasi (Classe)

Le eventuali (Class) controlla se la classe è dello stesso tipo di oggetto reale:

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

3.10. allOf (Matcher ...) e anyOf (Matcher ...)

Possiamo usare allOf (Matcher ...) per affermare se l'oggetto effettivo corrisponde a tutte le condizioni specificate:

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

L'anyof (Matcher ...) si comporta come allof (Matcher ...) , ma le partite se l'oggetto in esame corrisponde a qualsiasi delle condizioni specificate:

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

3.11. hasItem (T) e hasItem (Matcher)

Corrispondono se la raccolta Iterable esaminata corrisponde a un dato oggetto o matcher all'interno di hasItem () o hasItem (Matcher) .

Capiamo come funziona:

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

Allo stesso modo, possiamo anche affermare contro più di un elemento utilizzando hasItems (T ...) e hasItems (Matcher ...) :

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

3.12. sia (Matcher) che (Matcher)

Come suggerisce il nome, entrambi (Matcher) corrispondono quando entrambe le condizioni specificate corrispondono all'oggetto esaminato:

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

e (Matcher) corrisponde quando una delle condizioni specificate corrisponde all'oggetto esaminato:

String testString = "daenerys targaryen"; assertThat(testString, either(startsWith("tar")).or(containsString("targaryen")));

4. Confronto di stringhe

Possiamo usare containsString (String) o containsStringIgnoringCase (String) per affermare se la stringa effettiva contiene una stringa di prova:

String testString = "Rhaegar Targaryen"; assertThat(testString, containsString("aegar")); assertThat(testString, containsStringIgnoringCase("AEGAR"));

Oppure startsWith (String) e startsWithIgnoringCase (String) per affermare se la stringa effettiva inizia con la stringa di prova:

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

Possiamo anche usare endswith (stringa) o endsWithIgnoringCase (stringa) di affermare se le estremità delle corde reali con stringa di prova:

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

5. conclusione

In questo articolo, abbiamo discusso diversi metodi di CoreMatchers classe in Hamcrest biblioteca.

E, come sempre, il codice sorgente per gli esempi può essere trovato su GitHub.