TOC

Hamcrest Common Core Matchers

Common Core Matcher von Hamcrest

1. Überblick

In diesem kurzen Tutorial werden wir dieCoreMatchers -Skala aus dem beliebtenHamcrest-Framework zum Schreiben einfacher und aussagekräftigerer Testfälle untersuchen.

Die Idee ist, Aussagen zu machen, die wie natürliche Sprache gelesen werden.

2. Hamcrest Setup

Wir können Hamcrest mit Maven verwenden, indem wir derpom.xml-Datei die folgende Abhängigkeit hinzufügen: 


    org.hamcrest
    java-hamcrest
    2.0.0.0
    test

Die neueste Version dieser Bibliothek befindet sich immer inhere.

3. Gemeinsame Core Matcher

3.1. is(T) undis(Matcher<T>)

is(T) verwendet ein Objekt als Parameter, um die Gleichheit zu überprüfen, undis(Matcher<T>) verwendet einen anderen Matcher, damit die Gleichheitsaussage aussagekräftiger wird.

We can use this with almost all of the methods: 

String testString = "hamcrest core";

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

3.2. equalTo(T)

DasequalTo(T) nimmt ein Objekt als Parameter und prüft seine Gleichheit mit einem anderen Objekt. This is frequently used with is(Matcher<T>): 

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

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

Wir können auchequalToObject(Object operand) – verwenden, das die Gleichheit überprüft und nicht erzwingt, dass zwei Objekte vom gleichen statischen Typ sind: 

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

3.3. not(T)andnot(Matcher<T>)

Dienot(T) undnot(Matcher<T>) werden verwendet, um die Ungleichheit gegebener Objekte zu überprüfen. Erstens nimmt ein Objekt als Argument und zweitens einen anderen 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() undnullValue(Class<T>)

DernullValue() check fürnull value gegen das untersuchte Objekt. DienullValue(Class<T>) prüft die Nullbarkeit eines bestimmten Klassentypobjekts: 

Integer nullObject = null;

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

3.5. notNullValue() undnotNullValue(Class<T>)

These are a shortcut to frequently used is(not(nullValue)). Diese Prüfung auf Nicht-Null-Gleichheit eines Objekts oder mit dem Klassentyp: 

Integer testNumber = 123;

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

3.6. instanceOf(Class<?>)

instanceOf(Class<?>) stimmt überein, wenn das untersuchte Objekt eine Instanz des angegebenenClass -Styps ist.

To verify, this method internally calls theisIntance(Object) of Class Klasse: 

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

3.7. isA(Class<T> type)

isA(Class<T> type) ist eine Verknüpfung zu den obigeninstanceOf(Class<?>). It takes the exact same type of argument as an instanceOf(Class<?>): 

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

3.8. sameInstance()

DiesameInstance() stimmen überein, wenn zwei Referenzvariablen auf dasselbe Objekt in einem Heap zeigen: 

String string1 = "Viseron";
String string2 = string1;

assertThat(string1, is(sameInstance(string2)));

3.9. any(Class<T>)

any(Class<T>)prüft, ob die Klasse vom selben Typ wie das tatsächliche Objekt ist: 

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

3.10. allOf(Matcher<? extends T>…) and anyOf(Matcher<? extends T>…)

Wir könnenallOf(Matcher<? extends T>…) verwenden, um zu bestätigen, ob das tatsächliche Objekt mit allen angegebenen Bedingungen übereinstimmt: 

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

anyOf(Matcher<? extends T>…) verhält sich wieallOf(Matcher<? extends T>… ), stimmt jedoch überein, wenn das untersuchte Objekt eine der angegebenen Bedingungen erfüllt: 

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

3.11. hasItem(T) undhasItem(Matcher<? extends T>)

Diese stimmen überein, wenn die untersuchteIterable -Sammlung mit einem bestimmten Objekt oder Matcher innerhalb vonhasItem() oderhasItem(Matcher<? extends T>) übereinstimmt.

Lassen Sie uns verstehen, wie das funktioniert: 

List list = Lists.newArrayList("java", "spring", "example");

assertThat(list, hasItem("java"));
assertThat(list, hasItem(isA(String.class)));

Similarly, we can also assert against more than one items using hasItems(T…)and hasItems(Matcher<? extends T>…): 

List list = Lists.newArrayList("java", "spring", "example");

assertThat(list, hasItems("java", "example"));
assertThat(list, hasItems(isA(String.class), endsWith("ing")));

3.12. both(Matcher<? extends T>) and either(Matcher<? extends T>)

Wie der Name schon sagt, wirdboth(Matcher<? extends T>) verschmiert, wenn beide angegebenen Bedingungen mit dem untersuchten Objekt übereinstimmen: 

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

undeither(Matcher<? extends T>)matches, wenn eine der angegebenen Bedingungen mit dem untersuchten Objekt übereinstimmt: 

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

4. String Vergleich

Wir könnencontainsString(String) odercontainsStringIgnoringCase(String) to assert verwenden, wenn die tatsächliche Zeichenfolge eine Testzeichenfolge enthält: 

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

OderstartsWith(String) undstartsWithIgnoringCase(String) to behaupten, wenn die eigentliche Zeichenfolge mit der Testzeichenfolge beginnt: 

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

Wir können auchendsWith(String) orendsWithIgnoringCase(String) verwenden, um zu bestätigen, ob die tatsächliche Zeichenfolge mit einer Testzeichenfolge endet: 

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

5. Fazit

In diesem Artikel haben wir verschiedene Methoden derCoreMatchers -Skala in derHamcrest -Slibrary besprochen.

Und wie immer kann der Quellcode für die Beispieleover on GitHub gefunden werden.

Related