Check if a Variable Is Null Using Hamcrest

Last updated: June 27, 2024

Written by: Kai Yuan

Reviewed by: Liam Williams

Testing

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

When we write unit tests in Java, particularly with the JUnit framework, we often need to verify that certain variables are null or not null. Hamcrest, a popular library of Matchers for creating flexible tests, provides a convenient way to achieve this.

In this quick tutorial, we’ll explore how to check if a variable is null or non-null using JUnit and Hamcrest’s Matchers.

2. Using Hamcrest’s assertThat()

To use Hamcrest, we need to add the dependency into the pom.xml:

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest</artifactId>
    <version>2.2</version>
    <scope>test</scope>
</dependency>

We can check the latest version in Maven Central.

Hamcrest’s assertThat() method and its Matchers allow us to write flexible assertions. Next, let’s have a look at how to assert a variable is or isn’t null using this approach.

Hamcrest offers null-related matcher methods in the org.hamcrest.core.IsNull class. For example, we can use the static methods nullValue() and notNullValue() to get the Matchers for null and non-null checks.

Also, Hamcrest groups commonly used Matchers in the org.hamcrest.Matchers class. In the Matchers class, nullValue() and notNullValue() methods are available as well. They simply call the corresponding methods in the IsNull class. Therefore, we can import static the methods from either class to use these methods and make the code easy to read:

import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;

We can use them like so:

String theNull = null;
assertThat(theNull, nullValue());
 
String theNotNull = "I am a good String";
assertThat(theNotNull, notNullValue());

For a non-null check, we can also combine Matchers and use not(nullValue()) as an alternative:

assertThat(theNotNull, not(nullValue()));

It’s worth noting that the not() method is from the org.hamcrest.core.IsNot class and it negates the match parameter’s logic.

3. Using JUnit’s null and Non-Null Assertions

As we’ve seen, Hamcrest’s matchers are convenient for performing null or non-null assertions. Alternatively, the assertNull() and assertNotNull() methods shipped with JUnit are straightforward to do these checks:

String theNull = null;
assertNull(theNull); 
 
String theNotNull = "I am a good String";
assertNotNull(theNotNull);

As the code shows, even without Matchers, the JUnit assertion methods remain easy to use and read when checking for nulls.

4. Conclusion

In this quick article, we’ve explored different ways to assert null and non-null variables effectively using JUnit and Hamcrest.

By using Hamcrest’s nullValue() and notNullValue() Matchers, we can easily check if variables are null or non-null in our unit tests. The library’s expressive syntax makes our tests more readable and maintainable.

Alternatively, JUnit’s standard assertNull() and assertNotNull() assertions are straightforward in doing this job.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.