Difference Between Mockito Core and Mockito Inline

1. Overview

Mockito is one of the most popular frameworks for creating mock objects in Java, and it offers Mockito Core and Mockito Inline as the two main libraries for unit testing with different features and use cases.

To learn more about testing with Mockito, check out our comprehensive Mockito series.

2. Mockito Core

One of the foundational libraries of Mockito is Mockito Core.  It provides the basic functionality for creating mocks, stubs, and spies. This library is sufficient for most common use cases, but has some limitations, particularly when dealing with final classes and static methods.

See the mocking example of Mockito Core here.

3. Mockito Inline

Mockito Inline is an extension of Mockito Core including additional capabilities for mocking final classes, final fields, static methods, and constructors. This library is useful when you need to mock or stub these types of methods or classes. In the latest version of Mockito Core, Mockito Inline became the default mock maker since Mockito Core version 5.0.0.

Now, let’s try it on our code. First, we need to add mockito-core in our pom.xml dependencies:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.11.0</version>
    <scope>test</scope>
</dependency>

3.1. Mocking Final Class

Let’s try to mock our final class, we need to make a new class with the name FinalClass:

public final class FinalClass {
    public String greet() {
        return "Hello, World!";
    }
}

Let’s take a look at these code implementations of mocking a final class:

@Test
void testFinalClassMock() {
    FinalClass finalClass = mock(FinalClass.class);
    when(finalClass.greet()).thenReturn("Mocked Greeting");

    assertEquals("Mocked Greeting", finalClass.greet());
}

In the code example above, we mock our finalClass then we stub our method named greet() to return a String value of “Mocked Greeting” instead of the original value, which is “Hello, World!”.

3.2. Mocking Final Field

Let’s try to mock our final field, we need to make a new class with the name ClassWithFinalField:

public class ClassWithFinalField {
    public final String finalField = "Original Value";

    public String getFinalField() {
        return finalField;
    }
}

Let’s take a look at these code implementations of mocking a final class:

@Test
void testFinalFieldMock() {
    ClassWithFinalField instance = mock(ClassWithFinalField.class);
    when(instance.getFinalField()).thenReturn("Mocked Value");

    assertEquals("Mocked Value", instance.getFinalField());
}

In the code example above, we mock our instance then we stub our method name getFinalField() to return a String value of “Mocked Value” instead of the original value, which is “Original Value”. 

3.3. Mocking Static Method

Let’s try to mock our static method, we need to make a new class with the name ClassWithStaticMethod:

public class ClassWithStaticMethod {
    public static String staticMethod() {
        return "Original Static Value";
    }
}

Let’s take a look at these code implementations of mocking a static method:

@Test
void testStaticMethodMock() {
    try (MockedStatic<ClassWithStaticMethod> mocked = mockStatic(ClassWithStaticMethod.class)) {
        mocked.when(ClassWithStaticMethod::staticMethod).thenReturn("Mocked Static Value");

        assertEquals("Mocked Static Value", ClassWithStaticMethod.staticMethod());
    }
}

In the code example above, we mock our class name ClassWithStaticMethod then we stub our method name staticMethod() to return a String value of “Mocked Static Value” instead of the original value, which is “Original Static Value”.

3.4. Mocking Constructor

Let’s try to mock our constructor, we need to make a new class with the name ClassWithConstructor:

public class ClassWithConstructor {
    private String name;

    public ClassWithConstructor(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

Let’s take a look at these code implementations of mocking a constructor:

@Test
void testConstructorMock() {
    try (MockedConstruction<ClassWithConstructor> mocked = mockConstruction(ClassWithConstructor.class,
            (mock, context) -> when(mock.getName()).thenReturn("Mocked Name"))) {

        ClassWithConstructor myClass = new ClassWithConstructor("test");
        assertEquals("Mocked Name", myClass.getName());
    }
}

In the code example above, we mock our class name ClassWithConstructor then we mock our field called name to have a String value of “Mocked Name” instead of the value set in the constructor, which is “test”.

4. Summary

Let’s summarize what we’ve learned so far:

5. Conclusion

In this tutorial, we can compare the differences between Mockito Core and Mockito Inline. Simply put, Mockito Core can mock, stub, and spy common cases in our Java code and can’t do anything related to final classes, final methods, static methods, and constructors. On the other hand, Mockito Inline can do what Mockito Core can’t, which is mock and stub final classes, final fields, static methods, and constructors.

The code examples are available over on GitHub.