Um pouco de uma configuração complicada. Configuração robolétrica, baseada em regras do PowerMockito.

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class, sdk = 21)
@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*"})
// Using "PrepareOnlyThis" prevents powermock from trying to instrument the whole hierarchy,
// part of which we've ignored (android.os.* in this case)
@PrepareOnlyThisForTest({ServiceCallbackBase.class}) // this class extends Handler, 
// so we need PrepareOnlyThis.  It also has some final methods we need to verify()
public class ServiceBaseTests {

  private class Foo {
    // nothing
  }

  @Rule
  public PowerMockRule rule = new PowerMockRule();

  private ServiceCallbackBase<Object, Foo> setupCallback( boolean hasValidContext, boolean allContextsCanceled ) {
    ServiceCallbackBase<Object, Foo> callback = PowerMockito.mock( ServiceCallbackBase.class );
    // EDIT:  I have converted these to PowerMockito.doReturn()s to no avail.
    PowerMockito.when( callback.hasValidContext() ).thenReturn( hasValidContext );
    PowerMockito.when( callback.allContextsAreCanceled( any( Message.class ) ) ).thenReturn( allContextsCanceled );
    PowerMockito.doNothing().when( callback ).preSendMessage( any( Message.class ) );
    return callback;
  }

Deve ser bastante rotineiro. Mas sempre que tento ligarverify em uma dessas instâncias simuladas de "retorno de chamada", por exemplo:

  private void test_notifyCallback( boolean isFromCache ) {
    ServiceCallbackBase<Object, Foo> callback = setupCallback( true, false );

    uut.addHandler( TestEnum.FOO, callback );
    uut.addHandler( TestEnum.BAR, PowerMockito.mock( ServiceCallbackBase.class ) );
    uut.addHandler( TestEnum.BAZ, PowerMockito.mock( ServiceCallbackBase.class ) );

    Response<Foo> foo = new Response<>( new Foo(), new ResponseStatus( 0, "Error" ) );
    uut.handleCallBack( TestEnum.FOO, foo, isFromCache );

    ArgumentCaptor<Message> captor = ArgumentCaptor.forClass( Message.class );

    // this line throws the error.  
    verify( callback ).preSendMessage( captor.capture() );

    assertThat( captor.getValue().what ).isEqualTo( TestEnum.FOO.ordinal() );
    assertThat( captor.getValue().obj ).isEqualTo( foo );
    assertThat( captor.getValue().arg1 ).isEqualTo( isFromCache ? 1 : 0 );
  }

Eu recebo um erro assim:

org.mockito.exceptions.misusing.NotAMockException: 
Argument passed to verify() is of type ServiceCallbackBase$EnhancerByMockitoWithCGLIB$9acf906b and is not a mock!
Make sure you place the parenthesis correctly!
See the examples of correct verifications:
    verify(mock).someMethod();
    verify(mock, times(10)).someMethod();
    verify(mock, atLeastOnce()).someMethod();

É claro e obviamente foi "aprimorado" pelo mockito, e o PowerMock não tem um método confirm () para usar em vez deMockito.verify()... o que da?

EDITAR: isso é, de certa forma, mais e, de certa forma, menos confuso.

Estou no processo de construção de outra classe de teste para testar o ServiceCallbackBase em si. Se eu remover os testes dessa classe, eles serão aprovados. O fragmento a seguir em uma classe diferente faz com que os testes acima falhem.

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class, sdk = 21)
public class ServiceCallbackBaseTests {

  @Test
  public void test_nothing(){

  }

  private ServiceCallbackBase<Object, String> uutSpy;


  @Before
  public void setup(){
    uutSpy = mock( ServiceCallbackBase.class );
  }
}