@Override public void read( final PentoQuery query, final Distribution distribution, final PentoCallback handler, final OperationContext operationContext) { List<PentoStoreWorker> workers = readWorkerFactory.getWorkers(operationContext, distribution); for (PentoStoreWorker worker : workers) { Callable callable = worker.execute(query); ListenableFuture future = ioExecutor.submit(callable); Futures.addCallback( future, new FutureCallback() { public void onSuccess(Object response) { handler.callback(response); } public void onFailure(Throwable thrown) { logger.error(thrown.getMessage()); handler.error(thrown); } }); } }
// Error cases public void testSameThreadExecutionException() { SettableFuture<String> f = SettableFuture.create(); Exception e = new IllegalArgumentException("foo not found"); MockCallback callback = new MockCallback(e); Futures.addCallback(f, callback); f.setException(e); }
public void testExecutorSuccess() { CountingSameThreadExecutor ex = new CountingSameThreadExecutor(); SettableFuture<String> f = SettableFuture.create(); MockCallback callback = new MockCallback("foo"); Futures.addCallback(f, callback, ex); f.set("foo"); assertEquals(1, ex.runCount); }
public void testWildcardFuture() { SettableFuture<String> settable = SettableFuture.create(); ListenableFuture<?> f = settable; FutureCallback<Object> callback = new FutureCallback<Object>() { @Override public void onSuccess(Object result) {} @Override public void onFailure(Throwable t) {} }; Futures.addCallback(f, callback); }
@GwtIncompatible("Mockito") public void testOnSuccessThrowsRuntimeException() throws Exception { RuntimeException exception = new RuntimeException(); String result = "result"; SettableFuture<String> future = SettableFuture.create(); @SuppressWarnings("unchecked") // Safe for a mock FutureCallback<String> callback = Mockito.mock(FutureCallback.class); Futures.addCallback(future, callback); Mockito.doThrow(exception).when(callback).onSuccess(result); future.set(result); assertEquals(result, future.get()); Mockito.verify(callback).onSuccess(result); Mockito.verifyNoMoreInteractions(callback); }
@GwtIncompatible("Mockito") public void testOnSuccessThrowsError() throws Exception { class TestError extends Error {} TestError error = new TestError(); String result = "result"; SettableFuture<String> future = SettableFuture.create(); @SuppressWarnings("unchecked") // Safe for a mock FutureCallback<String> callback = Mockito.mock(FutureCallback.class); Futures.addCallback(future, callback); Mockito.doThrow(error).when(callback).onSuccess(result); try { future.set(result); fail("Should have thrown"); } catch (TestError e) { assertSame(error, e); } assertEquals(result, future.get()); Mockito.verify(callback).onSuccess(result); Mockito.verifyNoMoreInteractions(callback); }
public void testCancel() { SettableFuture<String> f = SettableFuture.create(); FutureCallback<String> callback = new FutureCallback<String>() { private boolean called = false; @Override public void onSuccess(String result) { fail("Was not expecting onSuccess() to be called."); } @Override public synchronized void onFailure(Throwable t) { assertFalse(called); assertThat(t).isInstanceOf(CancellationException.class); called = true; } }; Futures.addCallback(f, callback); f.cancel(true); }
public void testRuntimeExeceptionFromGet() { RuntimeException e = new IllegalArgumentException("foo not found"); ListenableFuture<String> f = ThrowingFuture.throwingRuntimeException(e); MockCallback callback = new MockCallback(e); Futures.addCallback(f, callback); }
public void testThrowErrorFromGet() { Error error = new AssertionError("ASSERT!"); ListenableFuture<String> f = ThrowingFuture.throwingError(error); MockCallback callback = new MockCallback(error); Futures.addCallback(f, callback); }
public void testSameThreadSuccess() { SettableFuture<String> f = SettableFuture.create(); MockCallback callback = new MockCallback("foo"); Futures.addCallback(f, callback); f.set("foo"); }