1. Overview
In this quick tutorial, we’ll explore the CoreMatchers class from the popular Hamcrest framework for writing simple and more expressive test cases.
The idea is to make assert statements read like natural language.
2. Hamcrest Setup
We can use Hamcrest with Maven by adding the following dependency to our pom.xml file:
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>java-hamcrest</artifactId>
<version>2.0.0.0</version>
<scope>test</scope>
</dependency>
The latest version of this library can always be found here.
3. Common Core Matchers
3.1. is(T) and is(Matcher)
The is(T) takes an object as a parameter to check equality and is(Matcher
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)
The equalTo(T) takes an object as a parameter and checks its equality against another object. *This is frequently used with is(Matcher
String actualString = "equalTo match";
List<String> actualList = Lists.newArrayList("equalTo", "match");
assertThat(actualString, is(equalTo("equalTo match")));
assertThat(actualList, is(equalTo(Lists.newArrayList("equalTo", "match"))));
We can also use equalToObject(Object operand) – which checks equality and doesn’t enforce that two objects should of same static type:
Object original = 100;
assertThat(original, equalToObject(100));
3.3. not(T) and not(Matcher)
The not(T) and not(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() and nullValue(Class)
The nullValue() check for null value against the examined object. The nullValue(Class
Integer nullObject = null;
assertThat(nullObject, is(nullValue()));
assertThat(nullObject, is(nullValue(Integer.class)));
3.5. notNullValue() and notNullValue(Class)
*These are a shortcut to frequently used is(not(nullValue)).* These check for non-null-equality of an object or with the class type:
Integer testNumber = 123;
assertThat(testNumber, is(notNullValue()));
assertThat(testNumber, is(notNullValue(Integer.class)));
3.6. instanceOf(Class<?>)
The instanceOf(Class<?>) matches if the examined object is an instance of the specified Class type.
To verify, this method internally calls the isIntance(Object) of Class class:
assertThat("instanceOf example", is(instanceOf(String.class)));
3.7. isA(Class type) **
The isA(Class
assertThat("Drogon is biggest dragon", isA(String.class));
3.8. sameInstance()
The sameInstance() matches if two reference variables point to the same object in a heap:
String string1 = "Viseron";
String string2 = string1;
assertThat(string1, is(sameInstance(string2)));
3.9. any(Class)
The *any(Class
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>…)
We can use allOf(Matcher<? extends T>…) to assert if actual object matches against all of the specified conditions:
String testString = "Achilles is powerful";
assertThat(testString, allOf(startsWith("Achi"), endsWith("ul"), containsString("Achilles")));
The anyOf(Matcher<? extends T>…) behaves like allOf(Matcher<? extends T>… ) but matches if the examined object matches any of the specified conditions:
String testString = "Hector killed Achilles";
assertThat(testString, anyOf(startsWith("Hec"), containsString("baeldung")));
3.11. hasItem(T) and hasItem(Matcher<? extends T>)
These match if the examined Iterable collection matches with given object or matcher inside hasItem() or hasItem(Matcher<? extends T>).
Let’s understand how this works:
List<String> list = Lists.newArrayList("java", "spring", "baeldung");
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<String> list = Lists.newArrayList("java", "spring", "baeldung");
assertThat(list, hasItems("java", "baeldung"));
assertThat(list, hasItems(isA(String.class), endsWith("ing")));
3.12. both(Matcher<? extends T>) and either(Matcher<? extends T>)
As the name suggests, the both(Matcher<? extends T>) matches when both of the specified conditions match the examined object:
String testString = "daenerys targaryen";
assertThat(testString, both(startsWith("daene")).and(containsString("yen")));
and *either(Matcher<? extends T>)*matches when either of the specified conditions matches the examined object:
String testString = "daenerys targaryen";
assertThat(testString, either(startsWith("tar")).or(containsString("targaryen")));
4. String Comparison
We can use containsString(String) or containsStringIgnoringCase(String) to assert if the actual string contains test string:
String testString = "Rhaegar Targaryen";
assertThat(testString, containsString("aegar"));
assertThat(testString, containsStringIgnoringCase("AEGAR"));
Or startsWith(String) and startsWithIgnoringCase(String) to assert if the actual string starts with test string:
assertThat(testString, startsWith("Rhae"));
assertThat(testString, startsWithIgnoringCase("rhae"));
We can also use endsWith(String) or endsWithIgnoringCase(String) to assert if the actual string ends with test string:
assertThat(testString, endsWith("aryen"));
assertThat(testString, endsWithIgnoringCase("ARYEN"));
5. Conclusion
In this article, we discussed different methods of CoreMatchers class in Hamcrest library.
And, as always, the source code for the examples can be found over on GitHub.