How to use shouldShowParametersWhenParamsAreHuge method of org.mockitousage.stubbing.StubbingWithThrowablesTest class

Here is a solution that will work for you particular case:

First of all you need to create a PersonMixin since you cannot add the required annotations to the mock.

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonProperty;


@JsonAutoDetect(getterVisibility = JsonAutoDetect.Visibility.NONE, isGetterVisibility = JsonAutoDetect.Visibility.NONE)
public interface PersonMixin {

    @JsonProperty
    String getName();

    @JsonProperty
    Integer getAge();
}

Now, use the object mapper like the in following code and you will get the same result as when you serialize the real object:

Person mockPerson = mock(Person.class);
when(mockPerson.getName()).thenReturn(name);
when(mockPerson.getAge()).thenReturn(age);
objectMapper.addMixInAnnotations(Person.class, PersonMixin.class);
try {
    System.out.println(objectMapper.writeValueAsString(mockPerson));
} catch (JsonProcessingException e) {
    e.printStackTrace();
    System.err.println("Failed to serialize mock object.");
}

As a temporary workaround, you can do the following:

trait MockitoHelper extends MockitoSugar {
  def doReturn(toBeReturned: Any): Stubber = {
    Mockito.doReturn(toBeReturned, Nil: _*)
  }
}

Then have your test mixin this MockitoHelper.

It should be something like

@RunWith(SpringJUnit4ClassRunner.class)
public class aTest () {

    @Mock
    private B b;

    @Mock
    private C c;

    @Autowired
    @InjectMocks
    private A a;

}

If you want D to be Autowired dont need to do anything in your Test class. Your Autowired A should have correct instance of D. Also i think you need to use SpringJUnit4ClassRunner for Autowiring to work, with contextConfiguration set correctly. Because you are not using MockitoJunitRunner you need to initialize your mocks yourself using

MockitoAnnotations.initMocks(java.lang.Object testClass)

I've already solved this just now. It may help you... maybe. A little instruction:

1. Go to Run -> Edit Configurations
2. Delete JUnit configuration on left panel

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))

You try to use deep stubbing without preparing your mock objects. Try

 WebTarget target = mock(WebTarget.class, Mockito.RETURNS_DEEP_STUBS);

The difference is, that the mock without deep stubbing returns default values on method calls (usually null). If you enclose such a call with Mockito.when this does not have an effect, but if you append further calls this leads to NullPointerExceptions, e.g. in

target
  .request()                          // return null
  .headers(any(MultivaluedMap.class)) // NullPointerException
  .post(any(Entity.class)))

However I would expect

mockClient
  .target(anyString())                // should return null
  .path(anyString()))                 // should throw NullPointerException

to fail too with NullPointerException, without activating deep stubs with

Client mockClient = mock(Client.class, Mockito.RETURNS_DEEP_STUBS);

Not that activating deep stubbing may be convenient for writing tests, but it can lead to strange behaviors in the tested code.

I had a similar problem while I was trying to start my tomcat. I would suggest that you check "Classpath" the following way:

1) Run Configurations

• Right click on your project
  • then click "Run" -> "Run Configurations..."
  • there check your settings for you project (e. g. in my case it was the Apache Tomcat)
  • here look into you tab "Classpath" under "User Entries"

2) Project classpath

• Right click on your project -> "Properties" -> "Java Build Path"
  • now check the "Source" Tab as well as your "Libraries" Tab
  • Problems should be marked red in the "Libraries" tab

You can use Mockito's answers, so instead of:

Mockito.when(client.get(Mockito.any(Request.class))).thenReturn("100");

write:

Mockito.when(client.get(Mockito.any(Request.class)))
 .thenAnswer(new Answer() {
   Object answer(InvocationOnMock invocation) {
     Object[] args = invocation.getArguments();
     Object mock = invocation.getMock();
     return "called with arguments: " + args;
   }
});

You're not passing the spy to when(). You're passing the original object.

Change the line

Mockito.spy(greeter);

to

greeter = Mockito.spy(greeter);

Mockito.spy() creates a spy object that is a copy of the original object. It doesn't modify the original object.