Matching Null With Mockito

Last updated: January 8, 2024

Written by: Thibault Faure

Reviewed by: David Martinez

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.

1. Overview

In this short tutorial, we’ll use Mockito to check if null is passed as an argument to a method. We’ll see how to match null directly and by using ArgumentMatchers.

2. Example Setup

First, let’s create a simple Helper class with a lone concat() method returning the concatenation of two Strings:

class Helper {

    String concat(String a, String b) {
        return a + b;
    }

}

We’ll now add a Main class. Its method methodUnderTest() calls concat() to concatenate the String Baeldung with null:

class Main {

    Helper helper = new Helper();

    String methodUnderTest() {
        return helper.concat("Baeldung", null);
    }

}

3. Using Only Exact Values

Let’s set up the test class:

class MainUnitTest {

    @Mock
    Helper helper;

    @InjectMocks
    Main main;

    @BeforeEach
    void openMocks() {
        MockitoAnnotations.openMocks(this);
    }

    // Add test method

}

We created a mocked Helper thanks to @Mock. Then we injected it into our Main instance via @InjectMocks. Lastly, we invoked MockitoAnnotations.openMocks() to enable Mockito annotations.

We aim to write a unit test to verify that methodUnderTest() delegates to concat(). Additionally, we want to ensure that the second argument is null. Let’s keep it simple and check that the first argument of the call is Baeldung while the second one is null:

@Test
void whenMethodUnderTest_thenSecondParameterNull() {
    main.methodUnderTest();
    Mockito.verify(helper)
      .concat("Baeldung", null);
}

We called Mockito.verify() to check that the argument values were the expected ones.

4. Using Matchers

We’ll now use Mockito’s ArgumentMatchers to check the passed values. As the first value is irrelevant in our example, we’ll use the any() matcher: thus, any input will pass. To check that the second parameter is null, we can simply use isNull():

@Test
void whenMethodUnderTest_thenSecondParameterNullWithMatchers() {
    main.methodUnderTest();
    Mockito.verify(helper)
      .concat(any(), isNull());
}

5. Conclusion

In this article, we learned how to verify that the argument passed to a method is null with Mockito. We did this both by checking exact values and by using ArgumentMatchers.

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.