Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

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.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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:

Element to Mock Mockito Function
 Final Classes
 mock(FinalClass.class)
 Final Fields
 mock(ClassWithFinalField.class)
 Static Methods
 mockStatic(ClassWithStaticMethod.class)
 Constructor
 mockConstruction(ClassWithConstructor.class)

 

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 backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW