How to use shouldAllowFewerCallsForMethodsOnDifferentMocks method of org.mockitousage.verification.BasicVerificationInOrderTest class

You can write your own Answer:

when(mock.testMethod(anyString())).thenAnswer(new Answer<String>() {
    @Override
    public String answer(InvocationOnMock invocation) {
        return invocation.getArgumentAt(0, String.class);
    }
});

Or:

when(mock.testMethod(anyString()))
    .thenAnswer(AdditionalAnswers.<String>returnsFirstArg());

The error message outlines the solution. The line

doNothing().when(cmd).dnsCheck(HOST, any(InetAddressFactory.class))

uses one raw value and one matcher, when it's required to use either all raw values or all matchers. A correct version might read

doNothing().when(cmd).dnsCheck(eq(HOST), any(InetAddressFactory.class))

• Unit test frameworks: JUnit / TestNG
• Mocking frameworks: JMock / EasyMock / Mockito
• Continuous Integration tools: CruiseControl / Hudson
• Requirements testing: Fit / FitNesse
• Code coverage: Cobertura
• Automated UI testing: Selenium
• Other tools: HTTPUnit / DBUnit
• Mutation Testing PITest
• Contract tester: EqualsVerifier (Ok, full disclosure: I made this one myself.)

New feature added to Mockito makes this even easier,

ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
verify(mock).doSomething(argument.capture());
assertEquals("John", argument.getValue().getName());

Take a look at Mockito documentation

In case when there are more than one parameters, and capturing of only single param is desired, use other ArgumentMatchers to wrap the rest of the arguments:

verify(mock).doSomething(eq(someValue), eq(someOtherValue), argument.capture());
assertEquals("John", argument.getValue().getName());

when(
  fooDao.getBar(
    any(Bazoo.class)
  )
).thenReturn(myFoo);

or (to avoid nulls):

when(
  fooDao.getBar(
    (Bazoo)notNull()
  )
).thenReturn(myFoo);

Don't forget to import matchers (many others are available):

For Mockito 2.1.0 and newer:

import static org.mockito.ArgumentMatchers.*;

For older versions:

import static org.mockito.Matchers.*;

You should instantiante testRef as follows:

Test testRef = new Test(taskJob) {

    public void updateAndReschedule(Long id, String message) {
        //do nothing
    }

};

No need for the spy.

Mockito mock works when we mock the objects loosely.

Here is the change i have made to make it work:

when(controlWfDefTypeService.getDqCntlWfDefnTypCd(any(DqCntlWfDefn.class))
    .thenReturn(dqCntlWfDefnTyp);

Instead of passing the object of the Mock class, I passed the class with the Matcher any() and it works.

Test without CDI

A simple solution is to combine CDI with Constructor Injection, and forget about Guice for the test:

public class MyCommand {
    private final MyService service;

    @Inject
    public MyCommand(MyService service) {
        this.service = service;
    }

    public boolean executeSomething() {
        return service.doSomething() > 0;
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyCommandTest {
    @Mock
    MyServiceImpl serviceMock;
    private MyCommand command;

    @Before public void beforeEach() {
        MockitoAnnotations.initMocks(this);
        when(serviceMock.doSomething()).thenReturn(-1); // <- Error here

        // inject without Guice
        command = new MyCommand(serviceMock);
    }
}

Test with Mockito doing CDI

Else, if you do not like Constructor Injection, the test code should look like this:

@RunWith(MockitoJUnitRunner.class)
public class MyCommandTest {
    @Mock
    MyServiceImpl serviceMock;
    @InjectMocks 
    private MyCommand command;

    private AutoCloseable mockHandler;

    @Before
    public void beforeEach() {
        // initialize members annotated with @Mock and @InjectMocks
        mockHandler = MockitoAnnotations.openMocks(this);

        when(serviceMock.doSomething()).thenReturn(-1); // <- Error here
    }

    @After
    public void afterEach() throws Exception {
        mockHandler.close();
    }
}

There is a type-safe way: use ArgumentMatchers.any() and qualify it with the type:

ArgumentMatchers.<AsyncCallback<ResponseX>>any()