How to use TestBCanEqualA method of org.mockito.internal.matchers.apachecommons.EqualsBuilderTest class

You probably want to populate a normal list with your mocked objects. E.g.

List<User> mockList = new ArrayList<>();

User mockUser1 = Mockito.mock(User.class);
// ...    

mockList.add(mockUser1);
// etc.

Note that by default, Mockito returns an empty collection for any mocked methods that returns a collection. So if you just want to return an empty list, Mockito will already do that for you.

Don't mock Plugin if it's the class you want to Unit test. It's the opposite! Also for a unit test I would definitely avoid creating a spring context, instead you should only do that for integration testing or some very rare / specific case.

Anyway I suppose you want to test the interactions between the plugin and the manager. So you should definitely read the Mockito documentation but here's a first start that get a mocked manager injected in the plugin.

@RunWith(MockitoJUinitRunner.class)
public class PluginTest {
    @Mock DistributionManager mockedManager;
    @InjectMocks Plugin testedPlugin = new Plugin(); // initialization not need when using Mockito 1.9.x

    @Test public void plugin_should_call_the_the_manager_on_doSomething() {
        // given
        // when
        // then
    }

    // other scenarios
}

Please note, that you only need to use eihter the JUnit runner MockitoJUinitRunner.class or the utility class and method MockitoAnnotations.init(), but not both!

Other remarks:

• As you are using JUnit 4.x you don't need to make your test method name begin by test, as those are annotated by @Test you can name them as whatever you want that is readable and expressive on the intent of the test.
• Same goes for set up and tear down methods, as they are respectively annotated by @Before and @After you can describe what your setting up or tearing down.
• And finally, don't name your test class PluginTestCase, the suffix TestCase was only used for abstract classes that would be extended by an actual test suffixed by Test such as MyClassTest. And anyway Maven Surefire will look for classes named *Test.

Well, it turns out I was wrong. Mockito uses CGLib and Objenesis to create the Object. If you follow that link it explains how it does not call the super class constructor.

This is easily tested with the following code:

public class Test
  public Test() {
    // Never called.
    System.out.println("Constructor was called.");
  }

  public static void main(String[] args) {
    Test test = mock(Test.class);
  }

You want to set up an Answer object that does that. Have a look at the Mockito documentation, at https://static.javadoc.io/org.mockito/mockito-core/2.8.47/org/mockito/Mockito.html#answer_stubs

You might write something like

when(mockService.doAction(any(Request.class), any(Callback.class))).thenAnswer(
    new Answer<Object>() {
        Object answer(InvocationOnMock invocation) {
            ((Callback<Response>) invocation.getArguments()[1]).reply(x);
            return null;
        }
});

(replacing x with whatever it ought to be, of course)

You either have to specify no matchers, or all the arguments need matches. So this:

when(userSubModuleDao.findById((any(UserSubModuleId.class)),false))

should be:

when(userSubModuleDao.findById(any(UserSubModuleId.class), eq(false)))

(I've removed the redundant brackets from around the any call.)

From the Matchers documentation:

Warning:

If you are using argument matchers, all arguments have to be provided by matchers.

According to https://groups.google.com/forum/?fromgroups#!topic/mockito/9WUvkhZUy90, you should rephrase your

when(bar.getFoo()).thenReturn(fooBar)

to

doReturn(fooBar).when(bar).getFoo()

You should matcher that matches long not any object:

verify(foo, times(1)).causeProblems(anyLong());

I checked that it runs correctly.

The following, running under Mockito 1.9.0 and JUnit 4.8.2, does not print anything to my console:

import static org.mockito.Mockito.*;

import org.junit.Test;

public class TestNonCall {
  public class TestClass {
    public String test() {
      System.out.println("test called!");
      return "test";
    }
  }

  @Test
  public void doTest() {
    final TestClass mock = mock(TestClass.class);

    when(mock.test()).thenReturn("mock!");
  }
}

Further, if I put a breakpoint in the test() method it is never hit.

Perhaps post more code? It looks like your example is not complex enough to demonstrate the behaviour you're having problems with.

Also: are you using the latest version of Mockito?

Edit: New Thought: Are You Mocking a Final Method?

If you add a final modifier to the method you are mocking, you get the behaviour you reported.

This is because Mockito does not mock final and static methods. Instead, it delegates the calls to the real implementation.

Might your actual code be attempting to mock a final method?

If so, you can use PowerMock, which is an extension to Mockito that allows mocking final methods.

You would need to add the following annotations to your test case class:

@RunWith(PowerMockRunner.class)
@PrepareForTest(TestClass.class)
public class TestNonCall {
  // ...
}

and mock the class using the PowerMock method in your test method:

final TestClass mock = PowerMockito.mock(TestClass.class);

then proceed as usual.

You may just do this:

Mockito.mock(Dog.class, Mockito.withSettings()
        .useConstructor(999)
        .defaultAnswer(Mockito.CALLS_REAL_METHODS)
);

Where 999 - is any integer for id argument. So you don't have to inherit your abstract class anymore. You also may pass as many arguments as constructor needed e.g.:

.useConstructor(new Object(), "my string", 5.5, null)