@Override public ListenableFuture<V> apply(V input) { return immediateFuture(input); } };
@Override public ListenableFuture<Object> reload(Object key, Object oldValue) { return Futures.immediateFuture(two); } };
@Override public ListenableFuture<Integer> apply(Integer input) { return immediateFuture(input + 1); } },
@Override public ListenableFuture<Object> reload(Object key, Object oldValue) { return Futures.immediateFuture(null); } };
@Override public ListenableFuture<Object> reload(Object key, Object oldValue) { return Futures.immediateFuture(two); } };
@Override public ListenableFuture<Integer> call() { callableCalled.set(true); return immediateFuture(1); } };
@Override public ListenableFuture<Object> apply(Object input) throws Exception { functionCalled.countDown(); functionBlocking.await(); return immediateFuture(null); }
@Override public ListenableFuture<Object> apply(Object input) throws Exception { functionCalled.countDown(); functionBlocking.await(); return immediateFuture(null); }
@Override public ListenableFuture<String> call() throws Exception { inFunction.countDown(); try { new CountDownLatch(1).await(); // wait for interrupt } catch (InterruptedException expected) { gotException.countDown(); throw expected; } return immediateFuture("a"); } };
@Override public ListenableFuture<Integer> apply(Throwable t) throws Exception { assertThat(t).isSameAs(raisedException); return immediateFuture(20); } });
@GwtIncompatible // Thread.interrupt public void testGetUnchecked_interrupted() { Thread.currentThread().interrupt(); try { assertEquals("foo", getUnchecked(immediateFuture("foo"))); assertTrue(Thread.currentThread().isInterrupted()); } finally { Thread.interrupted(); } }
public void testTransform_genericsNull() throws Exception { ListenableFuture<?> nullFuture = immediateFuture(null); ListenableFuture<?> transformedFuture = transform(nullFuture, constant(null), directExecutor()); assertNull(getDone(transformedFuture)); }
public void testAllAsList_immediateFailure() throws Exception { Throwable exception = new Throwable("failed"); ListenableFuture<String> future1 = immediateFailedFuture(exception); ListenableFuture<String> future2 = immediateFuture("results"); ListenableFuture<List<String>> compound = allAsList(ImmutableList.of(future1, future2)); try { getDone(compound); fail(); } catch (ExecutionException expected) { assertSame(exception, expected.getCause()); } }
public void testGetCheckedUntimed_badExceptionConstructor_failsEvenForSuccessfulInput() throws Exception { try { getChecked(immediateFuture("x"), ExceptionWithBadConstructor.class); fail(); } catch (IllegalArgumentException expected) { } }
public void testGetCheckedTimed_badExceptionConstructor_failsEvenForSuccessfulInput() throws Exception { try { getChecked(immediateFuture("x"), ExceptionWithBadConstructor.class, 1, TimeUnit.SECONDS); fail(); } catch (IllegalArgumentException expected) { } }
public void testCallableStartsAfterFirstFutureCompletes() { @SuppressWarnings({"unused", "nullness"}) Future<?> possiblyIgnoredError = serializer.submitAsync(firstCallable, directExecutor()); TestCallable secondCallable = new TestCallable(Futures.<Void>immediateFuture(null)); @SuppressWarnings({"unused", "nullness"}) Future<?> possiblyIgnoredError1 = serializer.submitAsync(secondCallable, directExecutor()); assertThat(firstCallable.called).isTrue(); assertThat(secondCallable.called).isFalse(); firstFuture.set(null); assertThat(secondCallable.called).isTrue(); }
public void testTransform_Executor() throws Exception { Object value = new Object(); ExecutorSpy spy = new ExecutorSpy(directExecutor()); assertFalse(spy.wasExecuted); ListenableFuture<Object> future = transform(immediateFuture(value), identity(), spy); assertSame(value, getDone(future)); assertTrue(spy.wasExecuted); }
public void testTransformAsync_genericsWildcard_AsyncFunction() throws Exception { ListenableFuture<?> nullFuture = immediateFuture(null); ListenableFuture<?> chainedFuture = transformAsync(nullFuture, constantAsyncFunction(nullFuture), directExecutor()); assertNull(getDone(chainedFuture)); }
private static void assertCannotSet(AbstractFuture<Integer> future) { assertThat(future.set(99)).isFalse(); assertThat(future.setException(new IndexOutOfBoundsException())).isFalse(); assertThat(future.setFuture(new AbstractFuture<Integer>() {})).isFalse(); assertThat(future.setFuture(immediateFuture(99))).isFalse(); }
@GwtIncompatible // lazyTransform public void testLazyTransform() throws Exception { FunctionSpy<Object, String> spy = new FunctionSpy<>(constant("bar")); Future<String> input = immediateFuture("foo"); Future<String> transformed = lazyTransform(input, spy); spy.verifyCallCount(0); assertEquals("bar", getDone(transformed)); spy.verifyCallCount(1); assertEquals("bar", getDone(transformed)); spy.verifyCallCount(2); }