test_class.declarator: mExecutor
test_class.modifier: @Mock
      private
test_class.original_string: @Mock
      private Executor mExecutor;
test_class.type: Executor
test_class.var_name: mExecutor
test_class.declarator: mProxyFactory
test_class.modifier: @Mock
      private
test_class.original_string: @Mock
      private ProxyFactory mProxyFactory;
test_class.type: ProxyFactory
test_class.var_name: mProxyFactory
test_class.declarator: mFailureHandler
test_class.modifier: @Mock
      private
test_class.original_string: @Mock
      private FailureHandler mFailureHandler;
test_class.type: FailureHandler
test_class.var_name: mFailureHandler
test_class.declarator: mActorImpl
test_class.modifier: @Mock
      private
test_class.original_string: @Mock
      private Runnable mActorImpl;
test_class.type: Runnable
test_class.var_name: mActorImpl
test_class.declarator: mProxy
test_class.modifier: @Mock
      private
test_class.original_string: @Mock
      private Runnable mProxy;
test_class.type: Runnable
test_class.var_name: mProxy
test_class.declarator: mThread
test_class.modifier: private
test_class.original_string: private ExecutorActorThread mThread;
test_class.type: ExecutorActorThread
test_class.var_name: mThread
test_class.file: actors-library/src/test/java/com/truecaller/androidactors/ExecutorActorThreadTest.java
test_class.identifier: ExecutorActorThreadTest
test_case.body: @SuppressWarnings({"unchecked", "ThrowableNotThrown"})
      @Test
      public void messageExceptionTest() throws Exception {
          ActorRef<Runnable> runnableRef = mThread.bind(Runnable.class, mActorImpl);
          // Check that we provided correct proxy class
          Assert.assertSame(mProxy, runnableRef.tell());
          // Grab postman and check it
          ArgumentCaptor<MessageSender> postmanCaptor = ArgumentCaptor.forClass(MessageSender.class);
          Mockito.verify(mProxyFactory).newProxy(Mockito.<Class>any(), postmanCaptor.capture());
  
          final Message message = Mockito.mock(Message.class);
          final RuntimeException exception = Mockito.mock(RuntimeException.class);
          final ActorMethodInvokeException callException = Mockito.mock(ActorMethodInvokeException.class);
          Mockito.doThrow(exception).when(message).invoke(Mockito.any());
          Mockito.doReturn(callException).when(message).exception();
          final MessageSender postman = postmanCaptor.getValue();
          postman.deliver(message);
  
          ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
          Mockito.verify(mExecutor).execute(runnableCaptor.capture());
          Runnable runnable = runnableCaptor.getValue();
          Assert.assertNotNull(runnable);
  
          // Check that we tried to invoke method
          runnable.run();
          // Check that we pass exception to handler
          Mockito.verify(mFailureHandler).onUncaughtException(mActorImpl, message, callException);
          Mockito.verify(callException).initCause(exception);
      }
test_case.class_method_signature: ExecutorActorThreadTest.messageExceptionTest()
test_case.full_signature: @SuppressWarnings({"unchecked", "ThrowableNotThrown"}) @Test public void messageExceptionTest()
test_case.identifier: messageExceptionTest
test_case.invocations: bind assertSame tell forClass newProxy verify any capture mock mock mock invoke when doThrow any exception when doReturn getValue deliver forClass execute verify capture getValue assertNotNull run onUncaughtException verify initCause verify
test_case.modifiers: @SuppressWarnings({"unchecked", "ThrowableNotThrown"}) @Test public
test_case.parameters: ()
test_case.return: void
test_case.signature: void messageExceptionTest()
focal_class.declarator: mExecutor
focal_class.modifier: @NonNull
      private final
focal_class.original_string: @NonNull
      private final Executor mExecutor;
focal_class.type: Executor
focal_class.var_name: mExecutor
focal_class.declarator: mProxyFactory
focal_class.modifier: @NonNull
      private final
focal_class.original_string: @NonNull
      private final ProxyFactory mProxyFactory;
focal_class.type: ProxyFactory
focal_class.var_name: mProxyFactory
focal_class.declarator: mFailureHandler
focal_class.modifier: @NonNull
      private final
focal_class.original_string: @NonNull
      private final FailureHandler mFailureHandler;
focal_class.type: FailureHandler
focal_class.var_name: mFailureHandler
focal_class.file: actors-library/src/main/java/com/truecaller/androidactors/ExecutorActorThread.java
focal_class.identifier: ExecutorActorThread
focal_class.interfaces: implements ActorThread
focal_class.class_method_signature: ExecutorActorThread.ExecutorActorThread(@NonNull Executor executor, @NonNull ProxyFactory proxyFactory,
                                        @NonNull FailureHandler failureHandler)
focal_class.full_signature:   ExecutorActorThread(@NonNull Executor executor, @NonNull ProxyFactory proxyFactory,
                                        @NonNull FailureHandler failureHandler)
focal_class.identifier: ExecutorActorThread
focal_class.parameters: (@NonNull Executor executor, @NonNull ProxyFactory proxyFactory,
                                        @NonNull FailureHandler failureHandler)
focal_class.signature:  ExecutorActorThread(@NonNull Executor executor, @NonNull ProxyFactory proxyFactory,
                                        @NonNull FailureHandler failureHandler)
focal_class.class_method_signature: ExecutorActorThread.bind(@NonNull Class<T> cls, @NonNull T impl)
focal_class.full_signature: @NonNull @Override public ActorRef<T> bind(@NonNull Class<T> cls, @NonNull T impl)
focal_class.identifier: bind
focal_class.modifiers: @NonNull @Override public
focal_class.parameters: (@NonNull Class<T> cls, @NonNull T impl)
focal_class.return: ActorRef<T>
focal_class.signature: ActorRef<T> bind(@NonNull Class<T> cls, @NonNull T impl)
focal_method.body: @NonNull
      @Override
      public <T> ActorRef<T> bind(@NonNull Class<T> cls, @NonNull T impl) {
          MessageSenderProxy<T> postman = new MessageSenderProxy<>(impl, mExecutor, mFailureHandler);
          T instance = mProxyFactory.newProxy(cls, postman);
          return new ActorRefImpl<>(instance);
      }
focal_method.class_method_signature: ExecutorActorThread.bind(@NonNull Class<T> cls, @NonNull T impl)
focal_method.full_signature: @NonNull @Override public ActorRef<T> bind(@NonNull Class<T> cls, @NonNull T impl)
focal_method.identifier: bind
focal_method.invocations: newProxy
focal_method.modifiers: @NonNull @Override public
focal_method.parameters: (@NonNull Class<T> cls, @NonNull T impl)
focal_method.return: ActorRef<T>
focal_method.signature: ActorRef<T> bind(@NonNull Class<T> cls, @NonNull T impl)