What does @Mock do? Can I use it with @BeforeClass?

This throws NPE in beforeClass() because o is null:

@RunWith(MockitoJUnitRunner.class)
public class FooTest {
    @Mock
    private static Object o;

    @BeforeClass
    public static void beforeClass() {
        when(o.toString()).thenReturn("foo");
    }

    @Test
    public void test() {
        o.toString();
    }
}

However, if I make it a non-static @Before method, it passes. If instead of using @Mock I write = mock(Object.class), it passes.

This seems strange. Is there anything I'm missing about @Mock? If its only purpose is to save you from writing mock(MyClass.class) (while forcing you to add @RunWith(MockitoJUnitRunner.class)), but it prevents you from using @BeforeClass, it seems like an unnecessary element that should be deprecated. Or is there something I'm missing that would allow me to use both these elements?

@Mock and Mockito.mock(MyClass.class) both have the same function. The main difference is that @Mock is considered by most as cleaner.

There are different points to mention in your tests:

• @BeforeEach require to use static fields and static methods as the methods executed in it are done during the initialisation phase, meaning before creating instances of classes.
• @Mock is executed after @BeforeClass, that why those annotations don't work together (the mock is not yet created when executing BeforeClass).
• Using Mockito.mock(MyClass.class) forces to create the mock during the execution of the method annotated with @BeforeClass, this is why it works.

> However, if I make it a non-static @Before method, it passes. If instead of using @Mock I write = mock(Object.class), it passes.
This seems strange. Is there anything I'm missing about @Mock?

@Mock is just an annotation that marks fields as being mock objects. Something has to fill in those fields with mocks. Per the documentation, you can do that with MockitoJUnitRunner or with initMocks.

If you do it with the runner, as you have illustrated, then your mocks will only be ready after the runner executes and in Mockito runners execute before each test but after the class has been initialized.

> If its only purpose is to save you from writing mock(MyClass.class) (while forcing you to add @RunWith(MockitoJUnitRunner.class)), but it prevents you from using @BeforeClass, it seems like an unnecessary element that should be deprecated. Or is there something I'm missing that would allow me to use both these elements?

You are trying to use an API that seems to be designed for instance fields on a static field. So it's not "unnecessary", it's just not applicable to your use case.

The easiest thing to do for your case would be to remove the RunsWith annotation and <strike>call initMocks as the first call in your beforeClass method</strike> just mock the object inline, as you already indicated: o = mock(MyObject.class).