How to use resetBuilder method of org.mockito.internal.junit.VerificationCollectorImpl class

You would need a spy, not a mock A:

    A a = Mockito.spy(new A(1,1));
    a.getPrice(2);
    verify(a, times(1)).getPriceForOne();

Some tools to support some practices:

• xUnit tools family for testing
• EasyMock + PowerMock (alternatives: Mockito, JMock) for mocking
• Cobertura (alternatives: EMMA, Clover) for code coverage
• Checkstyle, FindBugs, PMD for static analysis
• Hudson (alternatives: TeamCity, Bamboo) for Continuous Integration
• Sonar as QA dashboard
• XWiki (alternative: Trac, Confluence) for documentation and Knowledge Management
• Review Board (alternatives: Crucible, SmartBear) for Code Review

But these are just tools, tools won't make you Agile by themselves.

Take a look at the Mockito API docs. As the linked document mentions (Point # 12) you can use any of the doThrow(),doAnswer(),doNothing(),doReturn() family of methods from Mockito framework to mock void methods.

For example,

Mockito.doThrow(new Exception()).when(instance).methodName();

or if you want to combine it with follow-up behavior,

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

Presuming that you are looking at mocking the setter setState(String s) in the class World below is the code uses doAnswer method to mock the setState.

World mockWorld = mock(World.class); 
doAnswer(new Answer<Void>() {
    public Void answer(InvocationOnMock invocation) {
      Object[] args = invocation.getArguments();
      System.out.println("called with arguments: " + Arrays.toString(args));
      return null;
    }
}).when(mockWorld).setState(anyString());

You can just write

verify(service).perform((Collection<String>) Matchers.argThat(contains("a", "b")));

From the compiler's point of view, this is casting an Iterable<String> to a Collection<String> which is fine, because the latter is a subtype of the former. At run time, argThat will return null, so that can be passed to perform without a ClassCastException. The important point about it is that the matcher gets onto Mockito's internal structure of arguments for verification, which is what argThat does.

An alternative to ArgumentMatcher is ArgumentCaptor.

Official example:

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

A captor can also be defined using the @Captor annotation:

@Captor ArgumentCaptor<Person> captor;
//... MockitoAnnotations.initMocks(this);
@Test public void test() {
    //...
    verify(mock).doSomething(captor.capture());
    assertEquals("John", captor.getValue().getName());
}

You can call ArgumentCaptor.getAllValues() instead of getValue(). This will return all captured values:

Returns all captured values. Use it when capturing varargs or when the verified method was called multiple times.

In this case, it will return a List<String> containing 1 and 2.

The getValue() method only returns the last captured value:

Returns the captured value of the argument.

If the method was called multiple times then it returns the latest captured value

In your code, you can replace atLeastOnce() with the more precise times(2) since the mock was called 2 times. You don't need to have two distinct calls to verify to capture the arguments: Mockito will be able to capture all arguments passed to the mock with just one call.

TestMock mock = Mockito.mock(TestMock.class);
mock.doIt("1");
mock.doIt("2");

ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
verify(mock, times(2)).doIt(argument.capture()); // verify that it was call 2 times and capture the values given

System.out.println(argument.getAllValues());

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

Several of the methods on AbstractHttpClient are final and thus won't be mocked. IMO, this behavior is the #1 reason not to mock concrete classes.

You're surprised that the writes on the new objects aren't writing through to the backing collection?

Collections.transform doesn't just do the transform "as needed" -- it doesn't store anything at all. That's what "view" means in its documentation. Any time you walk through a Collections2.transformed collection, it applies the function again, freshly. Once that for loop in the apply method is done with result, that object is gone; never seen again.

If you want to do what you're doing, make an explicit copy of the transformed collection in e.g. an ArrayList.